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


#define SWIG_VERSION 0x040101
#define SWIGCSHARP
#define SWIG_DIRECTORS

/* -----------------------------------------------------------------------------
 *  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) do { if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } } while (0)

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


/* -----------------------------------------------------------------------------
 * 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) {
    }

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


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

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

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

#endif


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 <typeinfo>
#include <stdexcept>


#include <string>


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


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


#include <utility>


#include <ql/quantlib.hpp>

#if QL_HEX_VERSION < 0x01290000
    #error using an old version of QuantLib, please update
#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 calls 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 calls 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


// we do not want to see the deprecated warnings here
QL_DEPRECATED_DISABLE_WARNING


    namespace QuantLib { namespace ext {} }
    namespace ext = QuantLib::ext;


// 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 int Period_compareTo(Period const &lhs,Period const &rhs){
            return lhs < rhs  ? -1 :
                   lhs == rhs ?  0 :
                                 1;
        }
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 std::vector< Period >::value_type 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;
        #ifdef QL_HIGH_RESOLUTION_DATE
            out << QuantLib::io::iso_datetime(*self);
        #else
            out << *self;
        #endif
            return out.str();
        }
SWIGINTERN std::string Date___repr__(Date *self){
            std::ostringstream out;
            if (*self == Date())
                out << "Date()";
            else
        #ifdef QL_HIGH_RESOLUTION_DATE
                out << "Date(" << self->dayOfMonth() << ","
                    << int(self->month()) << "," << self->year() << ","
                    << self->hours() << "," << self->minutes() << ","
                    << self->seconds() << "," << self->milliseconds() << ","
                    << self->microseconds() << ")";
        #else
                out << "Date(" << self->dayOfMonth() << ","
                    << int(self->month()) << "," << self->year() << ")";
        #endif
            return out.str();
        }
SWIGINTERN std::string Date_ISO(Date *self){
            std::ostringstream out;
            out << QuantLib::io::iso_date(*self);
            return out.str();
        }
SWIGINTERN BigInteger Date_operator_Ss___SWIG_2(Date *self,Date const &other){
            return *self - other;
        }
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 std::vector< Date >::value_type 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;


template <class T, class U>
std::vector<T> to_vector(const std::vector<U>& v) {
    std::vector<T> out(v.size());
    std::copy(v.begin(), v.end(), out.begin());
    return out;
}

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 std::vector< int >::value_type 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 std::vector< unsigned int >::value_type 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 std::vector< double >::value_type 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::vector< std::string >::value_type 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::vector< double > > *new_std_vector_Sl_std_vector_Sl_double_Sg__Sg___SWIG_2(int capacity){
        std::vector< std::vector< double > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::vector< double > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::vector< double > std_vector_Sl_std_vector_Sl_double_Sg__Sg__getitemcopy(std::vector< std::vector< double > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< std::vector< double > >::value_type const &std_vector_Sl_std_vector_Sl_double_Sg__Sg__getitem(std::vector< 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_std_vector_Sl_double_Sg__Sg__setitem(std::vector< std::vector< double > > *self,int index,std::vector< 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_vector_Sl_double_Sg__Sg__AddRange(std::vector< std::vector< double > > *self,std::vector< std::vector< double > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::vector< double > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg__GetRange(std::vector< 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< std::vector< double > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__Insert(std::vector< std::vector< double > > *self,int index,std::vector< 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_vector_Sl_double_Sg__Sg__InsertRange(std::vector< std::vector< double > > *self,int index,std::vector< 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_std_vector_Sl_double_Sg__Sg__RemoveAt(std::vector< 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_std_vector_Sl_double_Sg__Sg__RemoveRange(std::vector< 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< std::vector< double > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg__Repeat(std::vector< double > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::vector< double > >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< double > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__Reverse__SWIG_1(std::vector< 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_std_vector_Sl_double_Sg__Sg__SetRange(std::vector< std::vector< double > > *self,int index,std::vector< 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 std::vector< std::pair< double,double > > *new_std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg___SWIG_2(int capacity){
        std::vector< std::pair< double,double > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::pair< double,double > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::pair< double,double > std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__getitemcopy(std::vector< std::pair< double,double > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< std::pair< double,double > >::value_type const &std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__getitem(std::vector< std::pair< double,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_double_Sc_double_Sg__Sg__setitem(std::vector< std::pair< double,double > > *self,int index,std::pair< double,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_double_Sc_double_Sg__Sg__AddRange(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::pair< double,double > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__GetRange(std::vector< std::pair< double,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< double,double > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__Insert(std::vector< std::pair< double,double > > *self,int index,std::pair< double,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_double_Sc_double_Sg__Sg__InsertRange(std::vector< std::pair< double,double > > *self,int index,std::vector< std::pair< double,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_double_Sc_double_Sg__Sg__RemoveAt(std::vector< std::pair< double,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_double_Sc_double_Sg__Sg__RemoveRange(std::vector< std::pair< double,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< double,double > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__Repeat(std::pair< double,double > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::pair< double,double > >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< double,double > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< double,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_double_Sc_double_Sg__Sg__SetRange(std::vector< std::pair< double,double > > *self,int index,std::vector< std::pair< double,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 std::vector< std::pair< unsigned int,unsigned int > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg___SWIG_2(int capacity){
        std::vector< std::pair< unsigned int,unsigned int > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::pair< unsigned int,unsigned int > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::pair< unsigned int,unsigned int > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,unsigned int > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int > >::value_type const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__getitem(std::vector< std::pair< unsigned int,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_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__setitem(std::vector< std::pair< unsigned int,unsigned int > > *self,int index,std::pair< unsigned int,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_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,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< std::pair< unsigned int,unsigned int > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__Insert(std::vector< std::pair< unsigned int,unsigned int > > *self,int index,std::pair< unsigned int,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_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,unsigned int > > *self,int index,std::vector< std::pair< unsigned int,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_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,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_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,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< std::pair< unsigned int,unsigned int > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__Repeat(std::pair< unsigned int,unsigned int > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::pair< unsigned int,unsigned int > >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,unsigned int > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,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_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,unsigned int > > *self,int index,std::vector< std::pair< unsigned int,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 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::vector< std::pair< Date,double > >::value_type 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::Calendar;


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


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

SWIGINTERN std::string Calendar___str__(Calendar *self){
            return self->name()+" calendar";
        }
SWIGINTERN std::vector< Calendar > *new_std_vector_Sl_Calendar_Sg___SWIG_2(int capacity){
        std::vector< Calendar >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< Calendar >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN Calendar std_vector_Sl_Calendar_Sg__getitemcopy(std::vector< Calendar > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< Calendar >::value_type const &std_vector_Sl_Calendar_Sg__getitem(std::vector< Calendar > *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_Calendar_Sg__setitem(std::vector< Calendar > *self,int index,Calendar const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Calendar_Sg__AddRange(std::vector< Calendar > *self,std::vector< Calendar > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< Calendar > *std_vector_Sl_Calendar_Sg__GetRange(std::vector< Calendar > *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< Calendar >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_Calendar_Sg__Insert(std::vector< Calendar > *self,int index,Calendar 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_Calendar_Sg__InsertRange(std::vector< Calendar > *self,int index,std::vector< Calendar > 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_Calendar_Sg__RemoveAt(std::vector< Calendar > *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_Calendar_Sg__RemoveRange(std::vector< Calendar > *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< Calendar > *std_vector_Sl_Calendar_Sg__Repeat(Calendar const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< Calendar >(count, value);
      }
SWIGINTERN void std_vector_Sl_Calendar_Sg__Reverse__SWIG_0(std::vector< Calendar > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_Calendar_Sg__Reverse__SWIG_1(std::vector< Calendar > *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_Calendar_Sg__SetRange(std::vector< Calendar > *self,int index,std::vector< Calendar > 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::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";
        }

using QuantLib::yearFractionToDate;


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::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 std::vector< InterestRate >::value_type 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::Observer;
using QuantLib::Observable;


struct SWIG_null_deleter {
  void operator() (void const *) const {
  }
};
#define SWIG_NO_NULL_DELETER_0 , SWIG_null_deleter()
#define SWIG_NO_NULL_DELETER_1
#define SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW
#define SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN


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

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){
            if (i < self->rows() && j < self->columns())
                return (*self)[i][j];
            else
                throw std::out_of_range("matrix indexes out of range");
        }
SWIGINTERN void Matrix_set(Matrix *self,Size i,Size j,Real x){
            if (i < self->rows() && j < self->columns())
                (*self)[i][j] = x;
            else
                throw std::out_of_range("matrix indexes out of range");
        }

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


using QuantLib::BiCGstab;
using QuantLib::GMRES;


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

class MatrixMultiplicationProxy {
  public:
    MatrixMultiplicationProxy(MatrixMultiplicationDelegate* delegate)
    : delegate_(delegate) {}
    
    Array operator()(const Array& x) const {
        Array retVal = delegate_->apply(x);        
        return retVal;
    }
               
  private:
      MatrixMultiplicationDelegate* const delegate_; 
};

SWIGINTERN Array BiCGstab_solve__SWIG_0(BiCGstab const *self,Array const &b,Array const &x0=Array()){
                return self->solve(b, x0).x; 
        }
SWIGINTERN BiCGstab *new_BiCGstab__SWIG_0(MatrixMultiplicationDelegate *delegate,Size maxIter,Real relTol){
        	MatrixMultiplicationProxy proxy(delegate);          
            return new BiCGstab(BiCGstab::MatrixMult(proxy), maxIter, relTol);                       
        }
SWIGINTERN BiCGstab *new_BiCGstab__SWIG_1(MatrixMultiplicationDelegate *delegate,Size maxIter,Real relTol,MatrixMultiplicationDelegate *preconditioner){              
        	MatrixMultiplicationProxy p1(delegate); 
        	MatrixMultiplicationProxy p2(preconditioner);
            return new BiCGstab(
                BiCGstab::MatrixMult(p1), maxIter, relTol, BiCGstab::MatrixMult(p2));                       
        }
SWIGINTERN Array GMRES_solve__SWIG_0(GMRES const *self,Array const &b,Array const &x0=Array()){
            return self->solve(b, x0).x;
        }
SWIGINTERN Array GMRES_solveWithRestart__SWIG_0(GMRES const *self,Size restart,Array const &b,Array const &x0=Array()){
            return self->solveWithRestart(restart, b, x0).x;
        }
SWIGINTERN GMRES *new_GMRES__SWIG_0(MatrixMultiplicationDelegate *delegate,Size maxIter,Real relTol){
        	MatrixMultiplicationProxy proxy(delegate);              
            return new GMRES(GMRES::MatrixMult(proxy), maxIter, relTol);                       
        }
SWIGINTERN GMRES *new_GMRES__SWIG_1(MatrixMultiplicationDelegate *delegate,Size maxIter,Real relTol,MatrixMultiplicationProxy const &preconditioner){
        	MatrixMultiplicationProxy p1(delegate); 
        	MatrixMultiplicationProxy p2(preconditioner);                                      
            return new GMRES(
                GMRES::MatrixMult(p1), maxIter, relTol, GMRES::MatrixMult(p2));                       
        }

using QuantLib::close;
using QuantLib::close_enough;


using QuantLib::CostFunction;


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

class UnaryFunction {
  public:
    UnaryFunction(UnaryFunctionDelegate* delegate)
    : delegate_(delegate) { }

    virtual ~UnaryFunction() { }

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

  private:
    UnaryFunctionDelegate* delegate_;
};


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

class BinaryFunction {
  public:
    BinaryFunction(BinaryFunctionDelegate* delegate)
    : delegate_(delegate) {}
    
    virtual ~BinaryFunction() {}
    
    Real operator()(Real x, Real y) const {
    	return delegate_->value(x, y);
    }
    
  private:
    BinaryFunctionDelegate* 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 Array values(const Array& x) const {
      Array retVal = delegate_->values(x);
      return retVal;
    }

  private:
    CostFunctionDelegate* delegate_;
};


using QuantLib::Quote;

SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_Quote_Sg__asObservable(Handle< Quote > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_Quote_Sg__reset(RelinkableHandle< Quote > *self){
            self->linkTo(ext::shared_ptr<Quote>());
        }

using QuantLib::SimpleQuote;
using QuantLib::LastFixingQuote;

SWIGINTERN std::vector< ext::shared_ptr< Quote > > *new_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<Quote> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<Quote> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< Quote > std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__getitemcopy(std::vector< ext::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< ext::shared_ptr< Quote > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__getitem(std::vector< ext::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_ext_shared_ptr_Sl_Quote_Sg__Sg__setitem(std::vector< ext::shared_ptr< Quote > > *self,int index,ext::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_ext_shared_ptr_Sl_Quote_Sg__Sg__AddRange(std::vector< ext::shared_ptr< Quote > > *self,std::vector< ext::shared_ptr< Quote > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< Quote > > *std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__GetRange(std::vector< ext::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< ext::shared_ptr<Quote> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Insert(std::vector< ext::shared_ptr< Quote > > *self,int index,ext::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_ext_shared_ptr_Sl_Quote_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< Quote > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_Quote_Sg__Sg__RemoveAt(std::vector< ext::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_ext_shared_ptr_Sl_Quote_Sg__Sg__RemoveRange(std::vector< ext::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< ext::shared_ptr< Quote > > *std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Repeat(ext::shared_ptr< Quote > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<Quote> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< Quote > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Reverse__SWIG_1(std::vector< ext::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_ext_shared_ptr_Sl_Quote_Sg__Sg__SetRange(std::vector< ext::shared_ptr< Quote > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_Quote_Sg__Sg__Contains(std::vector< ext::shared_ptr< Quote > > *self,ext::shared_ptr< Quote > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< Quote > > *self,ext::shared_ptr< Quote > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_Quote_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< Quote > > *self,ext::shared_ptr< Quote > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_Quote_Sg__Sg__Remove(std::vector< ext::shared_ptr< Quote > > *self,ext::shared_ptr< Quote > const &value){
        std::vector< ext::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< ext::shared_ptr< Quote > > > *new_std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg___SWIG_2(int capacity){
        std::vector< std::vector< ext::shared_ptr< Quote > > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::vector< ext::shared_ptr< Quote > > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::vector< ext::shared_ptr< Quote > > std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__getitemcopy(std::vector< std::vector< ext::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< std::vector< ext::shared_ptr< Quote > > >::value_type const &std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__getitem(std::vector< std::vector< ext::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_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__setitem(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__AddRange(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,std::vector< std::vector< ext::shared_ptr< Quote > > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< Quote > > > *std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__GetRange(std::vector< std::vector< ext::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< ext::shared_ptr< Quote > > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__Insert(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__InsertRange(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,int index,std::vector< std::vector< ext::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_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__RemoveAt(std::vector< std::vector< ext::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_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__RemoveRange(std::vector< std::vector< ext::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< ext::shared_ptr< Quote > > > *std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__Repeat(std::vector< ext::shared_ptr< Quote > > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::vector< ext::shared_ptr< Quote > > >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< ext::shared_ptr< Quote > > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__Reverse__SWIG_1(std::vector< std::vector< ext::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_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__SetRange(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,int index,std::vector< std::vector< ext::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 std::vector< Handle< Quote > >::value_type 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< std::vector< Handle< Quote > > >::value_type 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 std::vector< RelinkableHandle< Quote > >::value_type 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< std::vector< RelinkableHandle< Quote > > >::value_type 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::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);
        }

class NFunctAndDer {
  public:
    NFunctAndDer(const UnaryFunction& function,
                 const UnaryFunction& derivative)
    : f_(function), d_(derivative) {}
           
    Real operator()(Real x) const { return f_(x); }
    Real derivative(Real x) const { return d_(x); }
  private:          
    UnaryFunction f_, d_;
};

SWIGINTERN Real Newton_solve__SWIG_0(Newton *self,UnaryFunctionDelegate *function,UnaryFunctionDelegate *derivative,Real xAccuracy,Real guess,Real step){
            UnaryFunction f(function), d(derivative);            
            return self->solve(NFunctAndDer(f, d), xAccuracy, guess, step);
        }
SWIGINTERN Real Newton_solve__SWIG_1(Newton *self,UnaryFunctionDelegate *function,UnaryFunctionDelegate *derivative,Real xAccuracy,Real guess,Real xMin,Real xMax){
            UnaryFunction f(function), d(derivative);            
            return self->solve(NFunctAndDer(f, d), xAccuracy, guess, xMin, xMax);
        }
SWIGINTERN Real NewtonSafe_solve__SWIG_0(NewtonSafe *self,UnaryFunctionDelegate *function,UnaryFunctionDelegate *derivative,Real xAccuracy,Real guess,Real step){
            UnaryFunction f(function), d(derivative);            
            return self->solve(NFunctAndDer(f, d), xAccuracy, guess, step);
        }
SWIGINTERN Real NewtonSafe_solve__SWIG_1(NewtonSafe *self,UnaryFunctionDelegate *function,UnaryFunctionDelegate *derivative,Real xAccuracy,Real guess,Real xMin,Real xMax){
            UnaryFunction f(function), d(derivative);            
            return self->solve(NFunctAndDer(f, d), 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();
    }

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

typedef SafeInterpolation<QuantLib::LagrangeInterpolation> SafeLagrangeInterpolation;


// 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::CubicInterpolation;
using QuantLib::MixedInterpolation;
using QuantLib::BackwardFlat;
using QuantLib::ForwardFlat;
using QuantLib::Linear;
using QuantLib::LogLinear;
using QuantLib::Cubic;
using QuantLib::Bicubic;
using QuantLib::ConvexMonotone;
using QuantLib::DefaultLogCubic;
using QuantLib::MonotonicLogCubic;
using QuantLib::KrugerLog;

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

class SplineCubic : public Cubic {
  public:
    SplineCubic()
    : Cubic(CubicInterpolation::Spline, false,
            CubicInterpolation::SecondDerivative, 0.0,
            CubicInterpolation::SecondDerivative, 0.0) {}
};

class Kruger : public Cubic {
  public:
    Kruger()
    : Cubic(CubicInterpolation::Kruger) {}
};

class SplineLogCubic : public QuantLib::LogCubic {
  public:
    SplineLogCubic()
    : QuantLib::LogCubic(CubicInterpolation::Spline, false,
                         CubicInterpolation::SecondDerivative, 0.0,
                         CubicInterpolation::SecondDerivative, 0.0) {}
};

class LogMixedLinearCubic : public QuantLib::LogMixedLinearCubic {
  public:
    // We add defaults for all constructor arguments because wrappers for
    // InterpolatedDiscountCurve and PiecewiseYieldCurve assume that all
    // interpolators have default constructors.
    LogMixedLinearCubic(
        Size n = 0,
        MixedInterpolation::Behavior behavior = MixedInterpolation::ShareRanges,
        CubicInterpolation::DerivativeApprox da = CubicInterpolation::Spline,
        bool monotonic = true)
    : QuantLib::LogMixedLinearCubic(n, behavior, da, monotonic) {}
};


// safe version which copies its arguments
class SafeSABRInterpolation {
  public:
    SafeSABRInterpolation(const Array& x, const Array& y,
                          Time t,
                          Real forward,
                          Real alpha,
                          Real beta,
                          Real nu,
                          Real rho,
                          bool alphaIsFixed = false,
                          bool betaIsFixed = false,
                          bool nuIsFixed = false,
                          bool rhoIsFixed = false,
                          bool vegaWeighted = true,
                          const ext::shared_ptr<EndCriteria>& endCriteria
                                  = ext::shared_ptr<EndCriteria>(),
                          const ext::shared_ptr<OptimizationMethod>& optMethod
                                  = ext::shared_ptr<OptimizationMethod>(),
                          const Real errorAccept=0.0020,
                          const bool useMaxError=false,
                          const Size maxGuesses=50,
                          const Real shift = 0.0)
    : x_(x), y_(y), forward_(forward),
      f_(x_.begin(),x_.end(),y_.begin(),
         t, forward_, alpha, beta, nu, rho,
         alphaIsFixed, betaIsFixed,
         nuIsFixed, rhoIsFixed,
         vegaWeighted, endCriteria, optMethod,
         errorAccept, useMaxError, maxGuesses, shift) {f_.update();}
    Real operator()(Real x, bool allowExtrapolation=false) const {
        return f_(x, allowExtrapolation);
    }
    Real alpha() const {return f_.alpha();}
    Real beta() const {return f_.beta();}
    Real rho() const {return f_.rho();}
    Real nu() const {return f_.nu();}
    
  private:
    Array x_, y_;  // passed via iterators, need to stay alive
    Real forward_; // passed by reference, same
    QuantLib::SABRInterpolation f_;
};


using QuantLib::RichardsonExtrapolation;

SWIGINTERN RichardsonExtrapolation *new_RichardsonExtrapolation__SWIG_0(UnaryFunctionDelegate *fct,Real delta_h,Real n=Null< Real >()){
        
            UnaryFunction f(fct);
            return new RichardsonExtrapolation(f, delta_h, n); 
        }

class SafeConvexMonotoneInterpolation {
  public:
    SafeConvexMonotoneInterpolation(const Array& x, const Array& y,
                                    Real quadraticity = 0.3,
                                    Real monotonicity = 0.7,
                                    bool forcePositive = true)
    : x_(x), y_(y), f_(x_.begin(), x_.end(), y_.begin(),
                       quadraticity, monotonicity, forcePositive) {}
    Real operator()(Real x, bool allowExtrapolation=false) {
        return f_(x, allowExtrapolation);
    }
    Array x_, y_;
    QuantLib::ConvexMonotoneInterpolation<Array::const_iterator, Array::const_iterator> f_;
};


using QuantLib::ChebyshevInterpolation;

SWIGINTERN ChebyshevInterpolation *new_ChebyshevInterpolation__SWIG_2(Size n,UnaryFunctionDelegate *fct,ChebyshevInterpolation::PointsType pointsType=ChebyshevInterpolation::SecondKind){
        
            UnaryFunction f(fct);
            return new ChebyshevInterpolation(n, f, pointsType); 
        }

using QuantLib::TermStructure;


using QuantLib::YieldTermStructure;

SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_YieldTermStructure_Sg__asObservable(Handle< YieldTermStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_YieldTermStructure_Sg__reset(RelinkableHandle< YieldTermStructure > *self){
            self->linkTo(ext::shared_ptr<YieldTermStructure>());
        }

using QuantLib::ImpliedTermStructure;


using QuantLib::ZeroSpreadedTermStructure;
using QuantLib::ForwardSpreadedTermStructure;


using PiecewiseZeroSpreadedTermStructure = QuantLib::InterpolatedPiecewiseZeroSpreadedTermStructure<Linear>;


using SpreadedLinearZeroInterpolatedTermStructure = QuantLib::InterpolatedPiecewiseZeroSpreadedTermStructure<Linear>;


using SpreadedBackwardFlatZeroInterpolatedTermStructure = QuantLib::InterpolatedPiecewiseZeroSpreadedTermStructure<BackwardFlat>;


using QuantLib::FlatForward;


using QuantLib::UltimateForwardTermStructure;


using QuantLib::QuantoTermStructure;


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 std::vector< IntervalPrice >::value_type 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 void Index_addFixings__SWIG_0(Index *self,std::vector< Date > const &fixingDates,std::vector< Rate > const &fixings,bool forceOverwrite=false){
            self->addFixings(fixingDates.begin(),fixingDates.end(),
                             fixings.begin(),
                             forceOverwrite);
        }
SWIGINTERN std::string Index___str__(Index *self){
            return self->name()+" index";
        }

using QuantLib::InterestRateIndex;


using QuantLib::IborIndex;
using QuantLib::OvernightIndex;


    ext::shared_ptr<IborIndex> as_iborindex(
                          const ext::shared_ptr<InterestRateIndex>& index) {
        return ext::dynamic_pointer_cast<IborIndex>(index);
    }

SWIGINTERN ext::shared_ptr< OvernightIndex > OvernightIndex_clone(OvernightIndex const *self,Handle< YieldTermStructure > const &h){
            return ext::dynamic_pointer_cast<OvernightIndex>(self->clone(h));
        }

using QuantLib::Libor;
using QuantLib::DailyTenorLibor;


using QuantLib::SwapIndex;

SWIGINTERN std::vector< ext::shared_ptr< SwapIndex > > *new_std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<SwapIndex> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<SwapIndex> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< SwapIndex > std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< SwapIndex > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< SwapIndex > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__getitem(std::vector< ext::shared_ptr< SwapIndex > > *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_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__setitem(std::vector< ext::shared_ptr< SwapIndex > > *self,int index,ext::shared_ptr< SwapIndex > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__AddRange(std::vector< ext::shared_ptr< SwapIndex > > *self,std::vector< ext::shared_ptr< SwapIndex > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< SwapIndex > > *std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__GetRange(std::vector< ext::shared_ptr< SwapIndex > > *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< ext::shared_ptr<SwapIndex> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__Insert(std::vector< ext::shared_ptr< SwapIndex > > *self,int index,ext::shared_ptr< SwapIndex > 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_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< SwapIndex > > *self,int index,std::vector< ext::shared_ptr< SwapIndex > > 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_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__RemoveAt(std::vector< ext::shared_ptr< SwapIndex > > *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_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__RemoveRange(std::vector< ext::shared_ptr< SwapIndex > > *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< ext::shared_ptr< SwapIndex > > *std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__Repeat(ext::shared_ptr< SwapIndex > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<SwapIndex> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< SwapIndex > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__Reverse__SWIG_1(std::vector< ext::shared_ptr< SwapIndex > > *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_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__SetRange(std::vector< ext::shared_ptr< SwapIndex > > *self,int index,std::vector< ext::shared_ptr< SwapIndex > > 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_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__Contains(std::vector< ext::shared_ptr< SwapIndex > > *self,ext::shared_ptr< SwapIndex > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< SwapIndex > > *self,ext::shared_ptr< SwapIndex > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<SwapIndex> >::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_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< SwapIndex > > *self,ext::shared_ptr< SwapIndex > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<SwapIndex> >::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_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__Remove(std::vector< ext::shared_ptr< SwapIndex > > *self,ext::shared_ptr< SwapIndex > const &value){
        std::vector< ext::shared_ptr<SwapIndex> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }

    ext::shared_ptr<SwapIndex> as_swap_index(
                          const ext::shared_ptr<InterestRateIndex>& index) {
        return ext::dynamic_pointer_cast<SwapIndex>(index);
    }


using QuantLib::SwapSpreadIndex;


using QuantLib::EquityIndex;


using QuantLib::AUDLibor;


using QuantLib::CADLibor;


using QuantLib::CADLiborON;


using QuantLib::Cdor;


using QuantLib::CHFLibor;


using QuantLib::DKKLibor;


using QuantLib::Bbsw;


using QuantLib::Bbsw1M;


using QuantLib::Bbsw2M;


using QuantLib::Bbsw3M;


using QuantLib::Bbsw4M;


using QuantLib::Bbsw5M;


using QuantLib::Bbsw6M;


using QuantLib::Bkbm;


using QuantLib::Bkbm1M;


using QuantLib::Bkbm2M;


using QuantLib::Bkbm3M;


using QuantLib::Bkbm4M;


using QuantLib::Bkbm5M;


using QuantLib::Bkbm6M;


using QuantLib::Euribor;


using QuantLib::EuriborSW;


using QuantLib::Euribor2W;


using QuantLib::Euribor3W;


using QuantLib::Euribor1M;


using QuantLib::Euribor2M;


using QuantLib::Euribor3M;


using QuantLib::Euribor4M;


using QuantLib::Euribor5M;


using QuantLib::Euribor6M;


using QuantLib::Euribor7M;


using QuantLib::Euribor8M;


using QuantLib::Euribor9M;


using QuantLib::Euribor10M;


using QuantLib::Euribor11M;


using QuantLib::Euribor1Y;


using QuantLib::Euribor365;


using QuantLib::Euribor365_SW;


using QuantLib::Euribor365_2W;


using QuantLib::Euribor365_3W;


using QuantLib::Euribor365_1M;


using QuantLib::Euribor365_2M;


using QuantLib::Euribor365_3M;


using QuantLib::Euribor365_4M;


using QuantLib::Euribor365_5M;


using QuantLib::Euribor365_6M;


using QuantLib::Euribor365_7M;


using QuantLib::Euribor365_8M;


using QuantLib::Euribor365_9M;


using QuantLib::Euribor365_10M;


using QuantLib::Euribor365_11M;


using QuantLib::Euribor365_1Y;


using QuantLib::EURLibor;


using QuantLib::EURLiborSW;


using QuantLib::EURLibor2W;


using QuantLib::EURLibor1M;


using QuantLib::EURLibor2M;


using QuantLib::EURLibor3M;


using QuantLib::EURLibor4M;


using QuantLib::EURLibor5M;


using QuantLib::EURLibor6M;


using QuantLib::EURLibor7M;


using QuantLib::EURLibor8M;


using QuantLib::EURLibor9M;


using QuantLib::EURLibor10M;


using QuantLib::EURLibor11M;


using QuantLib::EURLibor1Y;


using QuantLib::GBPLibor;


using QuantLib::GBPLiborON;


using QuantLib::Jibar;


using QuantLib::JPYLibor;


using QuantLib::Mosprime;


using QuantLib::NZDLibor;


using QuantLib::Pribor;


using QuantLib::Robor;


using QuantLib::SEKLibor;


using QuantLib::Shibor;


using QuantLib::Tibor;


using QuantLib::THBFIX;


using QuantLib::TRLibor;


using QuantLib::USDLibor;


using QuantLib::USDLiborON;


using QuantLib::Wibor;


using QuantLib::Zibor;


using QuantLib::Aonia;


using QuantLib::Corra;


using QuantLib::Destr;


using QuantLib::Eonia;


using QuantLib::Estr;


using QuantLib::FedFunds;


using QuantLib::Nzocr;


using QuantLib::Sofr;


using QuantLib::Sonia;


using QuantLib::Swestr;


using QuantLib::EuriborSwapIsdaFixA;


using QuantLib::EuriborSwapIsdaFixB;


using QuantLib::EuriborSwapIfrFix;


using QuantLib::EurLiborSwapIsdaFixA;


using QuantLib::EurLiborSwapIsdaFixB;


using QuantLib::EurLiborSwapIfrFix;


using QuantLib::ChfLiborSwapIsdaFix;


using QuantLib::GbpLiborSwapIsdaFix;


using QuantLib::JpyLiborSwapIsdaFixAm;


using QuantLib::JpyLiborSwapIsdaFixPm;


using QuantLib::UsdLiborSwapIsdaFixAm;


using QuantLib::UsdLiborSwapIsdaFixPm;


using QuantLib::Bibor;


using QuantLib::BiborSW;


using QuantLib::Bibor1M;


using QuantLib::Bibor2M;


using QuantLib::Bibor3M;


using QuantLib::Bibor6M;


using QuantLib::Bibor9M;


using QuantLib::Bibor1Y;


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

SWIGINTERN Schedule MakeSchedule_schedule(MakeSchedule *self){
        return (Schedule)(* self);
      }

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


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

SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_BlackVolTermStructure_Sg__asObservable(Handle< BlackVolTermStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_BlackVolTermStructure_Sg__reset(RelinkableHandle< BlackVolTermStructure > *self){
            self->linkTo(ext::shared_ptr<BlackVolTermStructure>());
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_LocalVolTermStructure_Sg__asObservable(Handle< LocalVolTermStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_LocalVolTermStructure_Sg__reset(RelinkableHandle< LocalVolTermStructure > *self){
            self->linkTo(ext::shared_ptr<LocalVolTermStructure>());
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_OptionletVolatilityStructure_Sg__asObservable(Handle< OptionletVolatilityStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_OptionletVolatilityStructure_Sg__reset(RelinkableHandle< OptionletVolatilityStructure > *self){
            self->linkTo(ext::shared_ptr<OptionletVolatilityStructure>());
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_YoYOptionletVolatilitySurface_Sg__asObservable(Handle< YoYOptionletVolatilitySurface > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_YoYOptionletVolatilitySurface_Sg__reset(RelinkableHandle< YoYOptionletVolatilitySurface > *self){
            self->linkTo(ext::shared_ptr<YoYOptionletVolatilitySurface>());
        }

using QuantLib::SmileSection;

SWIGINTERN std::vector< ext::shared_ptr< SmileSection > > *new_std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<SmileSection> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<SmileSection> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< SmileSection > std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< SmileSection > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< SmileSection > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__getitem(std::vector< ext::shared_ptr< SmileSection > > *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_ext_shared_ptr_Sl_SmileSection_Sg__Sg__setitem(std::vector< ext::shared_ptr< SmileSection > > *self,int index,ext::shared_ptr< SmileSection > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__AddRange(std::vector< ext::shared_ptr< SmileSection > > *self,std::vector< ext::shared_ptr< SmileSection > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< SmileSection > > *std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__GetRange(std::vector< ext::shared_ptr< SmileSection > > *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< ext::shared_ptr<SmileSection> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__Insert(std::vector< ext::shared_ptr< SmileSection > > *self,int index,ext::shared_ptr< SmileSection > 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_ext_shared_ptr_Sl_SmileSection_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< SmileSection > > *self,int index,std::vector< ext::shared_ptr< SmileSection > > 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_ext_shared_ptr_Sl_SmileSection_Sg__Sg__RemoveAt(std::vector< ext::shared_ptr< SmileSection > > *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_ext_shared_ptr_Sl_SmileSection_Sg__Sg__RemoveRange(std::vector< ext::shared_ptr< SmileSection > > *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< ext::shared_ptr< SmileSection > > *std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__Repeat(ext::shared_ptr< SmileSection > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<SmileSection> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< SmileSection > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__Reverse__SWIG_1(std::vector< ext::shared_ptr< SmileSection > > *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_ext_shared_ptr_Sl_SmileSection_Sg__Sg__SetRange(std::vector< ext::shared_ptr< SmileSection > > *self,int index,std::vector< ext::shared_ptr< SmileSection > > 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_ext_shared_ptr_Sl_SmileSection_Sg__Sg__Contains(std::vector< ext::shared_ptr< SmileSection > > *self,ext::shared_ptr< SmileSection > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< SmileSection > > *self,ext::shared_ptr< SmileSection > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<SmileSection> >::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_ext_shared_ptr_Sl_SmileSection_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< SmileSection > > *self,ext::shared_ptr< SmileSection > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<SmileSection> >::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_ext_shared_ptr_Sl_SmileSection_Sg__Sg__Remove(std::vector< ext::shared_ptr< SmileSection > > *self,ext::shared_ptr< SmileSection > const &value){
        std::vector< ext::shared_ptr<SmileSection> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }

using QuantLib::SwaptionVolatilityStructure;

SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_SwaptionVolatilityStructure_Sg__asObservable(Handle< SwaptionVolatilityStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_SwaptionVolatilityStructure_Sg__reset(RelinkableHandle< SwaptionVolatilityStructure > *self){
            self->linkTo(ext::shared_ptr<SwaptionVolatilityStructure>());
        }

using QuantLib::BlackConstantVol;


using QuantLib::BlackVarianceCurve;


using QuantLib::BlackVarianceSurface;

SWIGINTERN BlackVarianceSurface *new_BlackVarianceSurface__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* surface =
                new BlackVarianceSurface(referenceDate,cal,
                                         dates,strikes,
                                         blackVols,dayCounter,lower,upper);
            std::string s = boost::to_lower_copy(interpolator);
            if (s == "" || s == "bilinear") {
                surface->setInterpolation<QuantLib::Bilinear>();
            } else if (s == "bicubic") {
                surface->setInterpolation<QuantLib::Bicubic>();
            } else {
                QL_FAIL("Unknown interpolator: " << interpolator);
            }
            return surface;
        }
SWIGINTERN void BlackVarianceSurface_setInterpolation__SWIG_0(BlackVarianceSurface *self,std::string const &interpolator=""){
            std::string s = boost::to_lower_copy(interpolator);
            if (s == "" || s == "bilinear") {
                self->setInterpolation<QuantLib::Bilinear>();
            } else if (s == "bicubic") {
                self->setInterpolation<QuantLib::Bicubic>();
            } else {
                QL_FAIL("Unknown interpolator: " << interpolator);
            }
        }

using QuantLib::ConstantOptionletVolatility;


using QuantLib::ConstantSwaptionVolatility;


using QuantLib::SwaptionVolatilityMatrix;
using QuantLib::SwaptionVolatilityDiscrete;

SWIGINTERN SwaptionVolatilityMatrix *new_SwaptionVolatilityMatrix__SWIG_12(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 SwaptionVolatilityMatrix(referenceDate, QuantLib::NullCalendar(), Following,
                                                dates, lengths, vols, dayCounter,
                                                flatExtrapolation, type, shifts);
        }
SWIGINTERN std::pair< unsigned int,unsigned int > SwaptionVolatilityMatrix_locate__SWIG_0(SwaptionVolatilityMatrix const *self,Date const &optionDate,Period const &swapTenor){
            auto sizes = self->locate(optionDate, swapTenor);
            return { (unsigned int)sizes.first, (unsigned int)sizes.second };
        }
SWIGINTERN std::pair< unsigned int,unsigned int > SwaptionVolatilityMatrix_locate__SWIG_1(SwaptionVolatilityMatrix const *self,Time optionTime,Time swapLength){
            auto sizes = self->locate(optionTime, swapLength);
            return { (unsigned int)sizes.first, (unsigned int)sizes.second };
        }

using QuantLib::SabrSmileSection;


using QuantLib::SviSmileSection;


using QuantLib::SviInterpolatedSmileSection;


using QuantLib::SwaptionVolatilityCube;
using QuantLib::SabrSwaptionVolatilityCube;
using QuantLib::InterpolatedSwaptionVolatilityCube;

SWIGINTERN ext::shared_ptr< SabrSmileSection > SabrSwaptionVolatilityCube_smileSection__SWIG_0(SabrSwaptionVolatilityCube const *self,Time optionTime,Time swapLength,bool extr=false){
            auto base = dynamic_cast<const SwaptionVolatilityStructure*>(self);
            return ext::dynamic_pointer_cast<SabrSmileSection>(base->smileSection(optionTime, swapLength, extr));
        }
SWIGINTERN ext::shared_ptr< SabrSmileSection > SabrSwaptionVolatilityCube_smileSection__SWIG_2(SabrSwaptionVolatilityCube const *self,Period const &optionTenor,Period const &swapTenor,bool extr=false){
            auto base = dynamic_cast<const SwaptionVolatilityStructure*>(self);
            return ext::dynamic_pointer_cast<SabrSmileSection>(base->smileSection(optionTenor, swapTenor, extr));
        }

using QuantLib::ConstantYoYOptionletVolatility;


using QuantLib::FlatSmileSection;


using QuantLib::InterpolatedSmileSection;
using QuantLib::Actual365Fixed;


using QuantLib::KahaleSmileSection;


using QuantLib::ZabrShortMaturityLognormal;
using QuantLib::ZabrShortMaturityNormal;
using QuantLib::ZabrLocalVolatility;
using QuantLib::ZabrFullFd;
using QuantLib::ZabrSmileSection;
using QuantLib::ZabrInterpolatedSmileSection;
using QuantLib::NoArbSabrSmileSection;
using QuantLib::NoArbSabrInterpolatedSmileSection;
using QuantLib::Option;


using QuantLib::sabrVolatility;
using QuantLib::shiftedSabrVolatility;
using QuantLib::sabrFlochKennedyVolatility;


using QuantLib::AndreasenHugeVolatilityInterpl;
using QuantLib::AndreasenHugeVolatilityAdapter;
using QuantLib::AndreasenHugeLocalVolAdapter;
using QuantLib::HestonBlackVolSurface;

SWIGINTERN double ext_tuple_Sl_Real_Sc_Real_Sc_Real_Sg__first(ext::tuple< Real,Real,Real > const *self){
        return ext::get<0>(*self);
      }
SWIGINTERN double ext_tuple_Sl_Real_Sc_Real_Sc_Real_Sg__second(ext::tuple< Real,Real,Real > const *self){
        return ext::get<1>(*self);
      }
SWIGINTERN double ext_tuple_Sl_Real_Sc_Real_Sc_Real_Sg__third(ext::tuple< Real,Real,Real > const *self){
        return ext::get<2>(*self);
      }

using QuantLib::CmsMarket;


using QuantLib::CmsMarketCalibration;


using QuantLib::CashFlow;
using QuantLib::Leg;

SWIGINTERN std::vector< ext::shared_ptr< CashFlow > > *new_std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<CashFlow> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<CashFlow> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< CashFlow > std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< CashFlow > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< CashFlow > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__getitem(std::vector< ext::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_ext_shared_ptr_Sl_CashFlow_Sg__Sg__setitem(std::vector< ext::shared_ptr< CashFlow > > *self,int index,ext::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_ext_shared_ptr_Sl_CashFlow_Sg__Sg__AddRange(std::vector< ext::shared_ptr< CashFlow > > *self,std::vector< ext::shared_ptr< CashFlow > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< CashFlow > > *std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__GetRange(std::vector< ext::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< ext::shared_ptr<CashFlow> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__Insert(std::vector< ext::shared_ptr< CashFlow > > *self,int index,ext::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_ext_shared_ptr_Sl_CashFlow_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< CashFlow > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_CashFlow_Sg__Sg__RemoveAt(std::vector< ext::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_ext_shared_ptr_Sl_CashFlow_Sg__Sg__RemoveRange(std::vector< ext::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< ext::shared_ptr< CashFlow > > *std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__Repeat(ext::shared_ptr< CashFlow > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<CashFlow> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< CashFlow > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__Reverse__SWIG_1(std::vector< ext::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_ext_shared_ptr_Sl_CashFlow_Sg__Sg__SetRange(std::vector< ext::shared_ptr< CashFlow > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_CashFlow_Sg__Sg__Contains(std::vector< ext::shared_ptr< CashFlow > > *self,ext::shared_ptr< CashFlow > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< CashFlow > > *self,ext::shared_ptr< CashFlow > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_CashFlow_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< CashFlow > > *self,ext::shared_ptr< CashFlow > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_CashFlow_Sg__Sg__Remove(std::vector< ext::shared_ptr< CashFlow > > *self,ext::shared_ptr< CashFlow > const &value){
        std::vector< ext::shared_ptr<CashFlow> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< Leg > *new_std_vector_Sl_Leg_Sg___SWIG_2(int capacity){
        std::vector< Leg >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< Leg >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN Leg std_vector_Sl_Leg_Sg__getitemcopy(std::vector< Leg > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< CashFlow > > >::value_type const &std_vector_Sl_Leg_Sg__getitem(std::vector< Leg > *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_Leg_Sg__setitem(std::vector< Leg > *self,int index,Leg const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_Leg_Sg__AddRange(std::vector< Leg > *self,std::vector< Leg > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< Leg > *std_vector_Sl_Leg_Sg__GetRange(std::vector< Leg > *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< Leg >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_Leg_Sg__Insert(std::vector< Leg > *self,int index,Leg 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_Leg_Sg__InsertRange(std::vector< Leg > *self,int index,std::vector< Leg > 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_Leg_Sg__RemoveAt(std::vector< Leg > *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_Leg_Sg__RemoveRange(std::vector< Leg > *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< Leg > *std_vector_Sl_Leg_Sg__Repeat(Leg const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< Leg >(count, value);
      }
SWIGINTERN void std_vector_Sl_Leg_Sg__Reverse__SWIG_0(std::vector< Leg > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_Leg_Sg__Reverse__SWIG_1(std::vector< Leg > *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_Leg_Sg__SetRange(std::vector< Leg > *self,int index,std::vector< Leg > 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_Leg_Sg__Contains(std::vector< Leg > *self,Leg const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_Leg_Sg__IndexOf(std::vector< Leg > *self,Leg const &value){
        int index = -1;
        std::vector< Leg >::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_Leg_Sg__LastIndexOf(std::vector< Leg > *self,Leg const &value){
        int index = -1;
        std::vector< Leg >::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_Leg_Sg__Remove(std::vector< Leg > *self,Leg const &value){
        std::vector< Leg >::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::IndexedCashFlow;
using QuantLib::Redemption;
using QuantLib::AmortizingPayment;
using QuantLib::Coupon;
using QuantLib::FixedRateCoupon;
using QuantLib::FloatingRateCoupon;
using QuantLib::RateAveraging;
using QuantLib::OvernightIndexedCoupon;


    ext::shared_ptr<IndexedCashFlow> as_indexed_cashflow(const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<IndexedCashFlow>(cf);
    }


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


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


using QuantLib::FloatingRateCouponPricer;


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


    ext::shared_ptr<OvernightIndexedCoupon> as_overnight_indexed_coupon(
                                      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<OvernightIndexedCoupon>(cf);
    }


using QuantLib::CappedFlooredCoupon;


using QuantLib::IborCoupon;
using QuantLib::CappedFlooredIborCoupon;
using QuantLib::SubPeriodsCoupon;

SWIGINTERN void IborCoupon_createAtParCoupons(){
            IborCoupon::Settings::instance().createAtParCoupons();
        }
SWIGINTERN void IborCoupon_createIndexedCoupons(){
            IborCoupon::Settings::instance().createIndexedCoupons();
        }
SWIGINTERN bool IborCoupon_usingAtParCoupons(){
            return IborCoupon::Settings::instance().usingAtParCoupons();
        }

    ext::shared_ptr<SubPeriodsCoupon> as_sub_periods_coupon(
      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<SubPeriodsCoupon>(cf);
    }


using QuantLib::IborCouponPricer;
using QuantLib::BlackIborCouponPricer;
using QuantLib::SubPeriodsPricer;
using QuantLib::CompoundingRatePricer;
using QuantLib::AveragingRatePricer;


using QuantLib::CmsCoupon;
using QuantLib::CappedFlooredCmsCoupon;
using QuantLib::CmsSpreadCoupon;
using QuantLib::CappedFlooredCmsSpreadCoupon;


using QuantLib::CmsCouponPricer;
using QuantLib::AnalyticHaganPricer;
using QuantLib::NumericHaganPricer;
using QuantLib::GFunctionFactory;
using QuantLib::LinearTsrPricer;
using QuantLib::CmsSpreadCouponPricer;
using QuantLib::LognormalCmsSpreadPricer;

SWIGINTERN std::vector< ext::shared_ptr< CmsCouponPricer > > *new_std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<CmsCouponPricer> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<CmsCouponPricer> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< CmsCouponPricer > std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__getitem(std::vector< ext::shared_ptr< CmsCouponPricer > > *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_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__setitem(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,int index,ext::shared_ptr< CmsCouponPricer > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__AddRange(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,std::vector< ext::shared_ptr< CmsCouponPricer > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< CmsCouponPricer > > *std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__GetRange(std::vector< ext::shared_ptr< CmsCouponPricer > > *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< ext::shared_ptr<CmsCouponPricer> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__Insert(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,int index,ext::shared_ptr< CmsCouponPricer > 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_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,int index,std::vector< ext::shared_ptr< CmsCouponPricer > > 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_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__RemoveAt(std::vector< ext::shared_ptr< CmsCouponPricer > > *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_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__RemoveRange(std::vector< ext::shared_ptr< CmsCouponPricer > > *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< ext::shared_ptr< CmsCouponPricer > > *std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__Repeat(ext::shared_ptr< CmsCouponPricer > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<CmsCouponPricer> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< CmsCouponPricer > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__Reverse__SWIG_1(std::vector< ext::shared_ptr< CmsCouponPricer > > *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_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__SetRange(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,int index,std::vector< ext::shared_ptr< CmsCouponPricer > > 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_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__Contains(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,ext::shared_ptr< CmsCouponPricer > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,ext::shared_ptr< CmsCouponPricer > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<CmsCouponPricer> >::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_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,ext::shared_ptr< CmsCouponPricer > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<CmsCouponPricer> >::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_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__Remove(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,ext::shared_ptr< CmsCouponPricer > const &value){
        std::vector< ext::shared_ptr<CmsCouponPricer> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }

using QuantLib::EquityCashFlow;
using QuantLib::EquityCashFlowPricer;
using QuantLib::EquityQuantoCashFlowPricer;


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(),
                  const Period& exCouponPeriod = Period(),
                  const Calendar& exCouponCalendar = Calendar(),
                  BusinessDayConvention exCouponConvention = Unadjusted,
                  bool exCouponEndOfMonth = false,
                  const Calendar& paymentCalendar = Calendar(),
                  const Integer paymentLag = 0,
                  Compounding comp = Simple,
                  Frequency freq = Annual) {
    return QuantLib::FixedRateLeg(schedule)
        .withNotionals(nominals)
        .withCouponRates(couponRates, dayCount, comp, freq)
        .withPaymentAdjustment(paymentAdjustment)
        .withPaymentCalendar(paymentCalendar.empty() ? schedule.calendar() : paymentCalendar)
        .withPaymentLag(paymentLag)
        .withFirstPeriodDayCounter(firstPeriodDayCount)
        .withExCouponPeriod(exCouponPeriod,
                            exCouponCalendar,
                            exCouponConvention,
                            exCouponEndOfMonth);
}


Leg _IborLeg(const std::vector<Real>& nominals,
             const Schedule& schedule,
             const ext::shared_ptr<IborIndex>& 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,
             const Period& exCouponPeriod = Period(),
             const Calendar& exCouponCalendar = Calendar(),
             BusinessDayConvention exCouponConvention = Unadjusted,
             bool exCouponEndOfMonth = false,
             const Calendar& paymentCalendar = Calendar(),
             const Integer paymentLag = 0,
             ext::optional<bool> withIndexedCoupons = ext::nullopt) {
    return QuantLib::IborLeg(schedule, index)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withPaymentCalendar(paymentCalendar.empty() ? schedule.calendar() : paymentCalendar)
        .withPaymentLag(paymentLag)
        .withFixingDays(fixingDays)
        .withGearings(gearings)
        .withSpreads(spreads)
        .withCaps(caps)
        .withFloors(floors)
        .inArrears(isInArrears)
        .withExCouponPeriod(exCouponPeriod,
                            exCouponCalendar,
                            exCouponConvention,
                            exCouponEndOfMonth)
        .withIndexedCoupons(withIndexedCoupons);
}


Leg _OvernightLeg(const std::vector<Real>& nominals,
                  const Schedule& schedule,
                  const ext::shared_ptr<OvernightIndex>& index,
                  const DayCounter& paymentDayCounter = DayCounter(),
                  const BusinessDayConvention paymentConvention = Following,
                  const std::vector<Real>& gearings = std::vector<Real>(),
                  const std::vector<Spread>& spreads = std::vector<Spread>(),
                  bool telescopicValueDates = false,
                  RateAveraging::Type averagingMethod = RateAveraging::Compound,
                  const Calendar& paymentCalendar = Calendar(),
                  const Integer paymentLag = 0) {
    return QuantLib::OvernightLeg(schedule, index)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withPaymentCalendar(paymentCalendar.empty() ? schedule.calendar() : paymentCalendar)
        .withPaymentLag(paymentLag)
        .withGearings(gearings)
        .withSpreads(spreads)
        .withTelescopicValueDates(telescopicValueDates)
        .withAveragingMethod(averagingMethod);
}


Leg _CmsLeg(const std::vector<Real>& nominals,
            const Schedule& schedule,
            const ext::shared_ptr<SwapIndex>& 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,
            const Period& exCouponPeriod = Period(),
            const Calendar& exCouponCalendar = Calendar(),
            const BusinessDayConvention exCouponConvention = Unadjusted,
            bool exCouponEndOfMonth = false) {
    return QuantLib::CmsLeg(schedule, index)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withFixingDays(fixingDays)
        .withGearings(gearings)
        .withSpreads(spreads)
        .withCaps(caps)
        .withFloors(floors)
        .withExCouponPeriod(exCouponPeriod, exCouponCalendar,
                            exCouponConvention, exCouponEndOfMonth)
        .inArrears(isInArrears);
}


Leg _CmsZeroLeg(const std::vector<Real>& nominals,
                const Schedule& schedule,
                const ext::shared_ptr<SwapIndex>& 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>(),
                const Period& exCouponPeriod = Period(),
                const Calendar& exCouponCalendar = Calendar(),
                const BusinessDayConvention exCouponConvention = Unadjusted,
                bool exCouponEndOfMonth = false) {
    return QuantLib::CmsLeg(schedule, index)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withFixingDays(fixingDays)
        .withGearings(gearings)
        .withSpreads(spreads)
        .withCaps(caps)
        .withFloors(floors)
        .withExCouponPeriod(exCouponPeriod, exCouponCalendar,
                            exCouponConvention, exCouponEndOfMonth)
        .withZeroPayments();
}


Leg _CmsSpreadLeg(const std::vector<Real>& nominals,
            const Schedule& schedule,
            const ext::shared_ptr<SwapSpreadIndex>& 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) {
    return QuantLib::CmsSpreadLeg(schedule, index)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withFixingDays(fixingDays)
        .withGearings(gearings)
        .withSpreads(spreads)
        .withCaps(caps)
        .withFloors(floors)
        .inArrears(isInArrears);
}


Leg _SubPeriodsLeg(const std::vector<Real>& nominals,
                   const Schedule& schedule,
                   const ext::shared_ptr<IborIndex>& index,
                   const DayCounter& paymentDayCounter = DayCounter(),
                   const BusinessDayConvention paymentConvention = Following,
                   const Calendar& paymentCalendar = Calendar(),
                   Integer paymentLag = 0,
                   const std::vector<Natural>& fixingDays = std::vector<Natural>(),
                   const std::vector<Real>& gearings = std::vector<Real>(),
                   const std::vector<Spread>& couponSpreads = std::vector<Spread>(),
                   const std::vector<Spread>& rateSpreads = std::vector<Spread>(),
                   const Period& exCouponPeriod = Period(),
                   const Calendar& exCouponCalendar = Calendar(),
                   BusinessDayConvention exCouponConvention = Unadjusted,
                   bool exCouponEndOfMonth = false,
                   RateAveraging::Type averagingMethod = RateAveraging::Compound) {
    return QuantLib::SubPeriodsLeg(schedule, index)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withPaymentCalendar(paymentCalendar.empty() ? schedule.calendar() : paymentCalendar)
        .withPaymentLag(paymentLag)
        .withFixingDays(fixingDays)
        .withGearings(gearings)
        .withCouponSpreads(couponSpreads)
        .withRateSpreads(rateSpreads)
        .withExCouponPeriod(exCouponPeriod,
                            exCouponCalendar,
                            exCouponConvention,
                            exCouponEndOfMonth)
        .withAveragingMethod(averagingMethod);
}


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

SWIGINTERN ext::shared_ptr< CashFlow > CashFlows_previousCashFlow__SWIG_0(Leg const &leg,bool includeSettlementDateFlows,Date settlementDate=Date()){
            Leg::const_reverse_iterator i =
                QuantLib::CashFlows::previousCashFlow(
                    leg, includeSettlementDateFlows, settlementDate);

            if (i == leg.rend())
                return ext::shared_ptr<CashFlow>();
            else
                return *i;
        }
SWIGINTERN ext::shared_ptr< CashFlow > CashFlows_nextCashFlow__SWIG_0(Leg const &leg,bool includeSettlementDateFlows,Date settlementDate=Date()){
            Leg::const_iterator i =
                QuantLib::CashFlows::nextCashFlow(
                    leg, includeSettlementDateFlows, settlementDate);

            if (i == leg.end())
                return ext::shared_ptr<CashFlow>();
            else
                return *i;
        }
SWIGINTERN Real CashFlows_npv__SWIG_0(Leg const &leg,ext::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,ext::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 std::pair< Real,Real > CashFlows_npvbps__SWIG_0(Leg const &leg,ext::shared_ptr< YieldTermStructure > const &discountCurve,bool includeSettlementDateFlows,Date const &settlementDate=Date(),Date const &npvDate=Date()){
            return QuantLib::CashFlows::npvbps(leg, *discountCurve,
                                               includeSettlementDateFlows,
                                               settlementDate, npvDate);
        }
SWIGINTERN std::pair< Real,Real > CashFlows_npvbps__SWIG_3(Leg const &leg,Handle< YieldTermStructure > const &discountCurve,bool includeSettlementDateFlows,Date const &settlementDate=Date(),Date const &npvDate=Date()){
            return QuantLib::CashFlows::npvbps(leg, **discountCurve,
                                               includeSettlementDateFlows,
                                               settlementDate, npvDate);
        }
SWIGINTERN Rate CashFlows_atmRate__SWIG_0(Leg const &leg,ext::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::Dividend;


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


using QuantLib::DividendSchedule;

SWIGINTERN std::vector< ext::shared_ptr< Dividend > > *new_std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<Dividend> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<Dividend> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< Dividend > std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< Dividend > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< Dividend > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__getitem(std::vector< ext::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_ext_shared_ptr_Sl_Dividend_Sg__Sg__setitem(std::vector< ext::shared_ptr< Dividend > > *self,int index,ext::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_ext_shared_ptr_Sl_Dividend_Sg__Sg__AddRange(std::vector< ext::shared_ptr< Dividend > > *self,std::vector< ext::shared_ptr< Dividend > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< Dividend > > *std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__GetRange(std::vector< ext::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< ext::shared_ptr<Dividend> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__Insert(std::vector< ext::shared_ptr< Dividend > > *self,int index,ext::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_ext_shared_ptr_Sl_Dividend_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< Dividend > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_Dividend_Sg__Sg__RemoveAt(std::vector< ext::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_ext_shared_ptr_Sl_Dividend_Sg__Sg__RemoveRange(std::vector< ext::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< ext::shared_ptr< Dividend > > *std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__Repeat(ext::shared_ptr< Dividend > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<Dividend> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< Dividend > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__Reverse__SWIG_1(std::vector< ext::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_ext_shared_ptr_Sl_Dividend_Sg__Sg__SetRange(std::vector< ext::shared_ptr< Dividend > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_Dividend_Sg__Sg__Contains(std::vector< ext::shared_ptr< Dividend > > *self,ext::shared_ptr< Dividend > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< Dividend > > *self,ext::shared_ptr< Dividend > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_Dividend_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< Dividend > > *self,ext::shared_ptr< Dividend > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_Dividend_Sg__Sg__Remove(std::vector< ext::shared_ptr< Dividend > > *self,ext::shared_ptr< Dividend > const &value){
        std::vector< ext::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::Exercise;


using QuantLib::EuropeanExercise;
using QuantLib::AmericanExercise;
using QuantLib::BermudanExercise;
using QuantLib::RebatedExercise;
using QuantLib::SwingExercise;


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


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::StochasticProcess;

SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess > > *new_std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<StochasticProcess> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<StochasticProcess> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< StochasticProcess > std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< StochasticProcess > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__getitem(std::vector< ext::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_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__setitem(std::vector< ext::shared_ptr< StochasticProcess > > *self,int index,ext::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_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__AddRange(std::vector< ext::shared_ptr< StochasticProcess > > *self,std::vector< ext::shared_ptr< StochasticProcess > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess > > *std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__GetRange(std::vector< ext::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< ext::shared_ptr<StochasticProcess> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__Insert(std::vector< ext::shared_ptr< StochasticProcess > > *self,int index,ext::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_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< StochasticProcess > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__RemoveAt(std::vector< ext::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_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__RemoveRange(std::vector< ext::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< ext::shared_ptr< StochasticProcess > > *std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__Repeat(ext::shared_ptr< StochasticProcess > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<StochasticProcess> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< StochasticProcess > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__Reverse__SWIG_1(std::vector< ext::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_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__SetRange(std::vector< ext::shared_ptr< StochasticProcess > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__Contains(std::vector< ext::shared_ptr< StochasticProcess > > *self,ext::shared_ptr< StochasticProcess > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< StochasticProcess > > *self,ext::shared_ptr< StochasticProcess > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< StochasticProcess > > *self,ext::shared_ptr< StochasticProcess > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__Remove(std::vector< ext::shared_ptr< StochasticProcess > > *self,ext::shared_ptr< StochasticProcess > const &value){
        std::vector< ext::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;

SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess1D > > *new_std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<StochasticProcess1D> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<StochasticProcess1D> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< StochasticProcess1D > std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__getitem(std::vector< ext::shared_ptr< StochasticProcess1D > > *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_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__setitem(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,int index,ext::shared_ptr< StochasticProcess1D > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__AddRange(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,std::vector< ext::shared_ptr< StochasticProcess1D > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess1D > > *std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__GetRange(std::vector< ext::shared_ptr< StochasticProcess1D > > *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< ext::shared_ptr<StochasticProcess1D> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__Insert(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,int index,ext::shared_ptr< StochasticProcess1D > 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_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,int index,std::vector< ext::shared_ptr< StochasticProcess1D > > 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_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__RemoveAt(std::vector< ext::shared_ptr< StochasticProcess1D > > *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_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__RemoveRange(std::vector< ext::shared_ptr< StochasticProcess1D > > *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< ext::shared_ptr< StochasticProcess1D > > *std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__Repeat(ext::shared_ptr< StochasticProcess1D > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<StochasticProcess1D> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< StochasticProcess1D > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__Reverse__SWIG_1(std::vector< ext::shared_ptr< StochasticProcess1D > > *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_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__SetRange(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,int index,std::vector< ext::shared_ptr< StochasticProcess1D > > 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_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__Contains(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,ext::shared_ptr< StochasticProcess1D > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,ext::shared_ptr< StochasticProcess1D > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<StochasticProcess1D> >::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_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,ext::shared_ptr< StochasticProcess1D > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<StochasticProcess1D> >::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_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__Remove(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,ext::shared_ptr< StochasticProcess1D > const &value){
        std::vector< ext::shared_ptr<StochasticProcess1D> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }

using QuantLib::GeneralizedBlackScholesProcess;


using QuantLib::BlackScholesProcess;


using QuantLib::BlackScholesMertonProcess;


using QuantLib::BlackProcess;


using QuantLib::GarmanKohlagenProcess;


using QuantLib::Merton76Process;


using QuantLib::StochasticProcessArray;


using QuantLib::GeometricBrownianMotionProcess;


using QuantLib::VarianceGammaProcess;


using QuantLib::HestonProcess;


using QuantLib::BatesProcess;


using QuantLib::HullWhiteProcess;


using QuantLib::HullWhiteForwardProcess;


using QuantLib::G2Process;


using QuantLib::G2ForwardProcess;


using QuantLib::GsrProcess;


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


using QuantLib::OrnsteinUhlenbeckProcess;


using QuantLib::KlugeExtOUProcess;
using QuantLib::ExtendedOrnsteinUhlenbeckProcess;
using QuantLib::ExtOUWithJumpsProcess;

SWIGINTERN ExtendedOrnsteinUhlenbeckProcess *new_ExtendedOrnsteinUhlenbeckProcess__SWIG_3(Real speed,Volatility sigma,Real x0,UnaryFunctionDelegate *function,Real intEps=1e-4){
            
            const UnaryFunction f(function);
            return new ExtendedOrnsteinUhlenbeckProcess(
            	    speed, sigma, x0, f, 
            	    ExtendedOrnsteinUhlenbeckProcess::MidPoint, intEps);
        }

using QuantLib::GJRGARCHProcess;


using QuantLib::LazyObject;

SWIGINTERN void LazyObject_forwardFirstNotificationOnly(){
            LazyObject::Defaults::instance().forwardFirstNotificationOnly();
        }
SWIGINTERN void LazyObject_alwaysForwardNotifications(){
            LazyObject::Defaults::instance().alwaysForwardNotifications();
        }
SWIGINTERN bool LazyObject_forwardsAllNotifications(){
            return LazyObject::Defaults::instance().forwardsAllNotifications();
        }

using QuantLib::PricingEngine;


using QuantLib::Instrument;

SWIGINTERN std::vector< ext::shared_ptr< Instrument > > *new_std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<Instrument> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<Instrument> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< Instrument > std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< Instrument > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< Instrument > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__getitem(std::vector< ext::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_ext_shared_ptr_Sl_Instrument_Sg__Sg__setitem(std::vector< ext::shared_ptr< Instrument > > *self,int index,ext::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_ext_shared_ptr_Sl_Instrument_Sg__Sg__AddRange(std::vector< ext::shared_ptr< Instrument > > *self,std::vector< ext::shared_ptr< Instrument > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< Instrument > > *std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__GetRange(std::vector< ext::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< ext::shared_ptr<Instrument> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__Insert(std::vector< ext::shared_ptr< Instrument > > *self,int index,ext::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_ext_shared_ptr_Sl_Instrument_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< Instrument > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_Instrument_Sg__Sg__RemoveAt(std::vector< ext::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_ext_shared_ptr_Sl_Instrument_Sg__Sg__RemoveRange(std::vector< ext::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< ext::shared_ptr< Instrument > > *std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__Repeat(ext::shared_ptr< Instrument > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<Instrument> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< Instrument > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__Reverse__SWIG_1(std::vector< ext::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_ext_shared_ptr_Sl_Instrument_Sg__Sg__SetRange(std::vector< ext::shared_ptr< Instrument > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_Instrument_Sg__Sg__Contains(std::vector< ext::shared_ptr< Instrument > > *self,ext::shared_ptr< Instrument > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< Instrument > > *self,ext::shared_ptr< Instrument > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_Instrument_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< Instrument > > *self,ext::shared_ptr< Instrument > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_Instrument_Sg__Sg__Remove(std::vector< ext::shared_ptr< Instrument > > *self,ext::shared_ptr< Instrument > const &value){
        std::vector< ext::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;


using QuantLib::CompositeInstrument;


using QuantLib::CalibrationHelper;

SWIGINTERN std::vector< ext::shared_ptr< CalibrationHelper > > *new_std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<CalibrationHelper> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<CalibrationHelper> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< CalibrationHelper > std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< CalibrationHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__getitem(std::vector< ext::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_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__setitem(std::vector< ext::shared_ptr< CalibrationHelper > > *self,int index,ext::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_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__AddRange(std::vector< ext::shared_ptr< CalibrationHelper > > *self,std::vector< ext::shared_ptr< CalibrationHelper > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< CalibrationHelper > > *std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__GetRange(std::vector< ext::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< ext::shared_ptr<CalibrationHelper> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Insert(std::vector< ext::shared_ptr< CalibrationHelper > > *self,int index,ext::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_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< CalibrationHelper > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__RemoveAt(std::vector< ext::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_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__RemoveRange(std::vector< ext::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< ext::shared_ptr< CalibrationHelper > > *std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Repeat(ext::shared_ptr< CalibrationHelper > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<CalibrationHelper> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< CalibrationHelper > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Reverse__SWIG_1(std::vector< ext::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_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__SetRange(std::vector< ext::shared_ptr< CalibrationHelper > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Contains(std::vector< ext::shared_ptr< CalibrationHelper > > *self,ext::shared_ptr< CalibrationHelper > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< CalibrationHelper > > *self,ext::shared_ptr< CalibrationHelper > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< CalibrationHelper > > *self,ext::shared_ptr< CalibrationHelper > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Remove(std::vector< ext::shared_ptr< CalibrationHelper > > *self,ext::shared_ptr< CalibrationHelper > const &value){
        std::vector< ext::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;
using QuantLib::TermStructureConsistentModel;

SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_CalibratedModel_Sg__asObservable(Handle< CalibratedModel > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_CalibratedModel_Sg__reset(RelinkableHandle< CalibratedModel > *self){
            self->linkTo(ext::shared_ptr<CalibratedModel>());
        }

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


#include <complex>


using QuantLib::Payoff;


using QuantLib::Option;


using QuantLib::TypePayoff;
using QuantLib::FloatingTypePayoff;
using QuantLib::StrikedTypePayoff;


using QuantLib::DeltaVolQuote;

SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_DeltaVolQuote_Sg__asObservable(Handle< DeltaVolQuote > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_DeltaVolQuote_Sg__reset(RelinkableHandle< DeltaVolQuote > *self){
            self->linkTo(ext::shared_ptr<DeltaVolQuote>());
        }

using QuantLib::OneAssetOption;
using QuantLib::VanillaOption;
using QuantLib::ForwardVanillaOption;

SWIGINTERN SampledCurve VanillaOption_priceCurve(VanillaOption *self){
            return self->result<SampledCurve>("priceCurve");
        }
SWIGINTERN std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *new_std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg___SWIG_2(int capacity){
        std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__getitemcopy(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__getitem(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__setitem(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,int index,std::pair< ext::shared_ptr< VanillaOption >,ext::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_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__AddRange(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__GetRange(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__Insert(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,int index,std::pair< ext::shared_ptr< VanillaOption >,ext::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_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__InsertRange(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,int index,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__RemoveAt(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__RemoveRange(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__Repeat(std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__SetRange(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,int index,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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);
      }

using QuantLib::EuropeanOption;


using QuantLib::ForwardVanillaOption;


using QuantLib::QuantoVanillaOption;


using QuantLib::QuantoForwardVanillaOption;


using QuantLib::MultiAssetOption;


using QuantLib::AnalyticEuropeanEngine;


using QuantLib::HestonModel;

SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_HestonModel_Sg__asObservable(Handle< HestonModel > *self){
        return ext::shared_ptr<Observable>(*self);
    }

using QuantLib::PiecewiseTimeDependentHestonModel;


using QuantLib::AnalyticHestonEngine;

SWIGINTERN AnalyticHestonEngine::OptimalAlpha *new_AnalyticHestonEngine_OptimalAlpha(Time const t,ext::shared_ptr< AnalyticHestonEngine > const &engine){
                    return new AnalyticHestonEngine::OptimalAlpha(t, engine.get());
            }

extern "C" {
// Identical to the layout of System.Numerics.Complex, but does assume that it is
// LayoutKind.Sequential on the managed side
struct SwigSystemNumericsComplex {
  double real;
  double imag;
};
}

SWIGINTERN SwigSystemNumericsComplex SwigCreateSystemNumericsComplex(double real, double imag) {
  SwigSystemNumericsComplex cpx;
  cpx.real = real;
  cpx.imag = imag;
  return cpx;
}


using QuantLib::COSHestonEngine;


using QuantLib::ExponentialFittingHestonEngine;


using QuantLib::AnalyticPTDHestonEngine;


using QuantLib::BatesModel;


using QuantLib::BatesEngine;


using QuantLib::IntegralEngine;


using QuantLib::BinomialVanillaEngine;
using QuantLib::CoxRossRubinstein;
using QuantLib::JarrowRudd;
using QuantLib::AdditiveEQPBinomialTree;
using QuantLib::Trigeorgis;
using QuantLib::Tian;
using QuantLib::LeisenReimer;
using QuantLib::Joshi4;


using QuantLib::MCEuropeanEngine;
using QuantLib::MCEuropeanHestonEngine;
using QuantLib::MCAmericanEngine;
using QuantLib::MCDigitalEngine;
using QuantLib::PseudoRandom;
using QuantLib::LowDiscrepancy;
using QuantLib::LsmBasisSystem;

SWIGINTERN MCEuropeanEngine< PseudoRandom > *new_MCEuropeanEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,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){
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            return new MCEuropeanEngine<PseudoRandom>(process,
                                             timeSteps,
                                             timeStepsPerYear,
                                             brownianBridge,
                                             antitheticVariate,
                                             requiredSamples,
                                             requiredTolerance,
                                             maxSamples,
                                             seed);
        }
SWIGINTERN MCEuropeanEngine< LowDiscrepancy > *new_MCEuropeanEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,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){
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            return new MCEuropeanEngine<LowDiscrepancy>(process,
                                             timeSteps,
                                             timeStepsPerYear,
                                             brownianBridge,
                                             antitheticVariate,
                                             requiredSamples,
                                             requiredTolerance,
                                             maxSamples,
                                             seed);
        }
SWIGINTERN MCAmericanEngine< PseudoRandom > *new_MCAmericanEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool antitheticVariate=false,bool controlVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,intOrNull polynomOrder=2,LsmBasisSystem::PolynomialType polynomType=LsmBasisSystem::Monomial,int nCalibrationSamples=2048,ext::optional< bool > antitheticVariateCalibration=ext::nullopt,BigNatural seedCalibration=Null< Size >()){
            return new MCAmericanEngine<PseudoRandom>(process,
                                             timeSteps,
                                             timeStepsPerYear,
                                             antitheticVariate,
                                             controlVariate,
                                             requiredSamples,
                                             requiredTolerance,
                                             maxSamples,
                                             seed,
                                             polynomOrder,
                                             polynomType,
                                             nCalibrationSamples,
                                             antitheticVariateCalibration,
                                             seedCalibration);
        }
SWIGINTERN MCAmericanEngine< LowDiscrepancy > *new_MCAmericanEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool antitheticVariate=false,bool controlVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,intOrNull polynomOrder=2,LsmBasisSystem::PolynomialType polynomType=LsmBasisSystem::Monomial,int nCalibrationSamples=2048,ext::optional< bool > antitheticVariateCalibration=ext::nullopt,BigNatural seedCalibration=Null< Size >()){
            return new MCAmericanEngine<LowDiscrepancy>(process,
                                             timeSteps,
                                             timeStepsPerYear,
                                             antitheticVariate,
                                             controlVariate,
                                             requiredSamples,
                                             requiredTolerance,
                                             maxSamples,
                                             seed,
                                             polynomOrder,
                                             polynomType,
                                             nCalibrationSamples,
                                             antitheticVariateCalibration,
                                             seedCalibration);
        }
SWIGINTERN MCEuropeanHestonEngine< PseudoRandom > *new_MCEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< HestonProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            return new MCEuropeanHestonEngine<PseudoRandom>(process,
                                                   timeSteps,
                                                   timeStepsPerYear,
                                                   antitheticVariate,
                                                   requiredSamples,
                                                   requiredTolerance,
                                                   maxSamples,
                                                   seed);
        }
SWIGINTERN MCEuropeanHestonEngine< LowDiscrepancy > *new_MCEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< HestonProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            return new MCEuropeanHestonEngine<LowDiscrepancy>(process,
                                                   timeSteps,
                                                   timeStepsPerYear,
                                                   antitheticVariate,
                                                   requiredSamples,
                                                   requiredTolerance,
                                                   maxSamples,
                                                   seed);
        }
SWIGINTERN MCDigitalEngine< PseudoRandom > *new_MCDigitalEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,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){
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            return new MCDigitalEngine<PseudoRandom>(process,
                                            timeSteps,
                                            timeStepsPerYear,
                                            brownianBridge,
                                            antitheticVariate,
                                            requiredSamples,
                                            requiredTolerance,
                                            maxSamples,
                                            seed);
        }
SWIGINTERN MCDigitalEngine< LowDiscrepancy > *new_MCDigitalEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,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){
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            return new MCDigitalEngine<LowDiscrepancy>(process,
                                            timeSteps,
                                            timeStepsPerYear,
                                            brownianBridge,
                                            antitheticVariate,
                                            requiredSamples,
                                            requiredTolerance,
                                            maxSamples,
                                            seed);
        }

using QuantLib::BaroneAdesiWhaleyApproximationEngine;


using QuantLib::BjerksundStenslandApproximationEngine;


using QuantLib::JuQuadraticApproximationEngine;


using QuantLib::AnalyticDigitalAmericanEngine;


using QuantLib::AnalyticDigitalAmericanKOEngine;


using QuantLib::DividendVanillaOption;


using QuantLib::AnalyticDividendEuropeanEngine;


using QuantLib::QdPlusAmericanEngine;


using QuantLib::QdFpLegendreScheme;
using QuantLib::QdFpIterationScheme;
using QuantLib::QdFpLegendreTanhSinhScheme;
using QuantLib::QdFpTanhSinhIterationScheme;
using QuantLib::QdFpAmericanEngine;


using QuantLib::FdmSchemeDesc;


using QuantLib::FdmQuantoHelper;


using QuantLib::LocalVolTermStructure;
using QuantLib::FdBlackScholesVanillaEngine;
using QuantLib::FdBlackScholesShoutEngine;
using QuantLib::FdOrnsteinUhlenbeckVanillaEngine;
using QuantLib::FdBatesVanillaEngine;
using QuantLib::FdHestonVanillaEngine;


using QuantLib::AnalyticCEVEngine;
using QuantLib::FdCEVVanillaEngine;


using QuantLib::FdSabrVanillaEngine;


using QuantLib::FdHestonHullWhiteVanillaEngine;


using QuantLib::AnalyticHestonHullWhiteEngine;


using QuantLib::AnalyticH1HWEngine;


using QuantLib::ForwardVanillaEngine;
using QuantLib::QuantoEngine;
typedef ForwardVanillaEngine<AnalyticEuropeanEngine> ForwardEuropeanEngine;
typedef QuantoEngine<VanillaOption,AnalyticEuropeanEngine> QuantoEuropeanEngine;
typedef QuantoEngine<ForwardVanillaOption,AnalyticEuropeanEngine> QuantoForwardEuropeanEngine;


using QuantLib::AnalyticHestonForwardEuropeanEngine;
using QuantLib::MCForwardEuropeanBSEngine;
using QuantLib::MCForwardEuropeanHestonEngine;

SWIGINTERN MCForwardEuropeanBSEngine< PseudoRandom > *new_MCForwardEuropeanBSEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,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){
            return new MCForwardEuropeanBSEngine<PseudoRandom>(process,
                                                      timeSteps,
                                                      timeStepsPerYear,
                                                      brownianBridge,
                                                      antitheticVariate,
                                                      requiredSamples,
                                                      requiredTolerance,
                                                      maxSamples,
                                                      seed);
        }
SWIGINTERN MCForwardEuropeanBSEngine< LowDiscrepancy > *new_MCForwardEuropeanBSEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,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){
            return new MCForwardEuropeanBSEngine<LowDiscrepancy>(process,
                                                      timeSteps,
                                                      timeStepsPerYear,
                                                      brownianBridge,
                                                      antitheticVariate,
                                                      requiredSamples,
                                                      requiredTolerance,
                                                      maxSamples,
                                                      seed);
        }
SWIGINTERN MCForwardEuropeanHestonEngine< PseudoRandom > *new_MCForwardEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< HestonProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,bool controlVariate=false){
            return new MCForwardEuropeanHestonEngine<PseudoRandom>(process,
                                                          timeSteps,
                                                          timeStepsPerYear,
                                                          antitheticVariate,
                                                          requiredSamples,
                                                          requiredTolerance,
                                                          maxSamples,
                                                          seed,
                                                          controlVariate);
        }
SWIGINTERN MCForwardEuropeanHestonEngine< LowDiscrepancy > *new_MCForwardEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< HestonProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,bool controlVariate=false){
            return new MCForwardEuropeanHestonEngine<LowDiscrepancy>(process,
                                                          timeSteps,
                                                          timeStepsPerYear,
                                                          antitheticVariate,
                                                          requiredSamples,
                                                          requiredTolerance,
                                                          maxSamples,
                                                          seed,
                                                          controlVariate);
        }

using QuantLib::BlackCalculator;


using QuantLib::VarianceGammaEngine;


using QuantLib::FFTVarianceGammaEngine;


using QuantLib::GJRGARCHModel;


using QuantLib::AnalyticGJRGARCHEngine;


using QuantLib::MCEuropeanGJRGARCHEngine;

SWIGINTERN MCEuropeanGJRGARCHEngine< PseudoRandom > *new_MCEuropeanGJRGARCHEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< GJRGARCHProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            return new MCEuropeanGJRGARCHEngine<PseudoRandom>(process,
                                                     timeSteps,
                                                     timeStepsPerYear,
                                                     antitheticVariate,
                                                     requiredSamples,
                                                     requiredTolerance,
                                                     maxSamples,
                                                     seed);
        }
SWIGINTERN MCEuropeanGJRGARCHEngine< LowDiscrepancy > *new_MCEuropeanGJRGARCHEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< GJRGARCHProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            return new MCEuropeanGJRGARCHEngine<LowDiscrepancy>(process,
                                                     timeSteps,
                                                     timeStepsPerYear,
                                                     antitheticVariate,
                                                     requiredSamples,
                                                     requiredTolerance,
                                                     maxSamples,
                                                     seed);
        }

using QuantLib::MargrabeOption;
using QuantLib::AnalyticEuropeanMargrabeEngine;
using QuantLib::AnalyticAmericanMargrabeEngine;


using QuantLib::CompoundOption;
using QuantLib::AnalyticCompoundOptionEngine;


using QuantLib::SimpleChooserOption;
using QuantLib::AnalyticSimpleChooserEngine;


using QuantLib::ComplexChooserOption;
using QuantLib::AnalyticComplexChooserEngine;


using QuantLib::Average;
using QuantLib::ContinuousAveragingAsianOption;
using QuantLib::DiscreteAveragingAsianOption;

SWIGINTERN TimeGrid DiscreteAveragingAsianOption_timeGrid(DiscreteAveragingAsianOption *self){
            return self->result<TimeGrid>("TimeGrid");
        }

using QuantLib::AnalyticContinuousGeometricAveragePriceAsianEngine;
using QuantLib::AnalyticContinuousGeometricAveragePriceAsianHestonEngine;
using QuantLib::AnalyticDiscreteGeometricAveragePriceAsianEngine;
using QuantLib::AnalyticDiscreteGeometricAveragePriceAsianHestonEngine;
using QuantLib::AnalyticDiscreteGeometricAverageStrikeAsianEngine;


using QuantLib::MCDiscreteArithmeticAPEngine;
using QuantLib::MCDiscreteArithmeticAPHestonEngine;
using QuantLib::MCDiscreteArithmeticASEngine;
using QuantLib::MCDiscreteGeometricAPEngine;
using QuantLib::MCDiscreteGeometricAPHestonEngine;

SWIGINTERN MCDiscreteArithmeticAPEngine< PseudoRandom > *new_MCDiscreteArithmeticAPEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,bool brownianBridge=false,bool antitheticVariate=false,bool controlVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCDiscreteArithmeticAPEngine<PseudoRandom>(process,
                                                         brownianBridge,
                                                         antitheticVariate,
                                                         controlVariate,
                                                         requiredSamples,
                                                         requiredTolerance,
                                                         maxSamples,
                                                         seed);
        }
SWIGINTERN MCDiscreteArithmeticAPEngine< LowDiscrepancy > *new_MCDiscreteArithmeticAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,bool brownianBridge=false,bool antitheticVariate=false,bool controlVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCDiscreteArithmeticAPEngine<LowDiscrepancy>(process,
                                                         brownianBridge,
                                                         antitheticVariate,
                                                         controlVariate,
                                                         requiredSamples,
                                                         requiredTolerance,
                                                         maxSamples,
                                                         seed);
        }
SWIGINTERN MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *new_MCDiscreteArithmeticAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< HestonProcess > const &process,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool controlVariate=false){
            return new MCDiscreteArithmeticAPHestonEngine<PseudoRandom>(process,
                                                               antitheticVariate,
                                                               requiredSamples,
                                                               requiredTolerance,
                                                               maxSamples,
                                                               seed,
                                                               timeSteps,
                                                               timeStepsPerYear,
                                                               controlVariate);
        }
SWIGINTERN MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *new_MCDiscreteArithmeticAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< HestonProcess > const &process,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool controlVariate=false){
            return new MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy>(process,
                                                               antitheticVariate,
                                                               requiredSamples,
                                                               requiredTolerance,
                                                               maxSamples,
                                                               seed,
                                                               timeSteps,
                                                               timeStepsPerYear,
                                                               controlVariate);
        }
SWIGINTERN MCDiscreteArithmeticASEngine< PseudoRandom > *new_MCDiscreteArithmeticASEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCDiscreteArithmeticASEngine<PseudoRandom>(process,
                                                         brownianBridge,
                                                         antitheticVariate,
                                                         requiredSamples,
                                                         requiredTolerance,
                                                         maxSamples,
                                                         seed);
        }
SWIGINTERN MCDiscreteArithmeticASEngine< LowDiscrepancy > *new_MCDiscreteArithmeticASEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCDiscreteArithmeticASEngine<LowDiscrepancy>(process,
                                                         brownianBridge,
                                                         antitheticVariate,
                                                         requiredSamples,
                                                         requiredTolerance,
                                                         maxSamples,
                                                         seed);
        }
SWIGINTERN MCDiscreteGeometricAPEngine< PseudoRandom > *new_MCDiscreteGeometricAPEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCDiscreteGeometricAPEngine<PseudoRandom>(process,
                                                        brownianBridge,
                                                        antitheticVariate,
                                                        requiredSamples,
                                                        requiredTolerance,
                                                        maxSamples,
                                                        seed);
        }
SWIGINTERN MCDiscreteGeometricAPEngine< LowDiscrepancy > *new_MCDiscreteGeometricAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCDiscreteGeometricAPEngine<LowDiscrepancy>(process,
                                                        brownianBridge,
                                                        antitheticVariate,
                                                        requiredSamples,
                                                        requiredTolerance,
                                                        maxSamples,
                                                        seed);
        }
SWIGINTERN MCDiscreteGeometricAPHestonEngine< PseudoRandom > *new_MCDiscreteGeometricAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< HestonProcess > const &process,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >()){
            return new MCDiscreteGeometricAPHestonEngine<PseudoRandom>(process,
                                                              antitheticVariate,
                                                              requiredSamples,
                                                              requiredTolerance,
                                                              maxSamples,
                                                              seed,
                                                              timeSteps,
                                                              timeStepsPerYear);
        }
SWIGINTERN MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *new_MCDiscreteGeometricAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< HestonProcess > const &process,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >()){
            return new MCDiscreteGeometricAPHestonEngine<LowDiscrepancy>(process,
                                                              antitheticVariate,
                                                              requiredSamples,
                                                              requiredTolerance,
                                                              maxSamples,
                                                              seed,
                                                              timeSteps,
                                                              timeStepsPerYear);
        }

using QuantLib::ContinuousArithmeticAsianLevyEngine;


using QuantLib::FdBlackScholesAsianEngine;


using QuantLib::TurnbullWakemanAsianEngine;


using QuantLib::Barrier;


using QuantLib::BarrierOption;
using QuantLib::DividendBarrierOption;
using QuantLib::QuantoBarrierOption;


using QuantLib::PartialBarrier;


using QuantLib::PartialTimeBarrierOption;


using QuantLib::AnalyticPartialTimeBarrierOptionEngine;


using QuantLib::AnalyticBarrierEngine;
using QuantLib::MCBarrierEngine;

SWIGINTERN MCBarrierEngine< PseudoRandom > *new_MCBarrierEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,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 >(),bool isBiased=false,BigInteger seed=0){
            return new MCBarrierEngine<PseudoRandom>(process,
                                            timeSteps,
                                            timeStepsPerYear,
                                            brownianBridge,
                                            antitheticVariate,
                                            requiredSamples,
                                            requiredTolerance,
                                            maxSamples,
                                            isBiased,
                                            seed);
        }
SWIGINTERN MCBarrierEngine< LowDiscrepancy > *new_MCBarrierEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,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 >(),bool isBiased=false,BigInteger seed=0){
            return new MCBarrierEngine<LowDiscrepancy>(process,
                                            timeSteps,
                                            timeStepsPerYear,
                                            brownianBridge,
                                            antitheticVariate,
                                            requiredSamples,
                                            requiredTolerance,
                                            maxSamples,
                                            isBiased,
                                            seed);
        }

using QuantLib::QuantoEngine;
typedef QuantoEngine<BarrierOption,AnalyticBarrierEngine> QuantoBarrierEngine;


using QuantLib::FdBlackScholesBarrierEngine;
using QuantLib::FdBlackScholesRebateEngine;
using QuantLib::FdHestonBarrierEngine;
using QuantLib::FdHestonRebateEngine;


using QuantLib::AnalyticBinaryBarrierEngine;


using QuantLib::BinomialBarrierEngine;
using QuantLib::DiscretizedDermanKaniBarrierOption;


using QuantLib::VannaVolgaBarrierEngine;


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


using QuantLib::QuantoDoubleBarrierOption;


using QuantLib::AnalyticDoubleBarrierEngine;


using QuantLib::FdHestonDoubleBarrierEngine;


using QuantLib::SuoWangDoubleBarrierEngine;


using QuantLib::VannaVolgaDoubleBarrierEngine;


using QuantLib::AnalyticDoubleBarrierBinaryEngine;


using QuantLib::BinomialDoubleBarrierEngine;
using QuantLib::DiscretizedDermanKaniDoubleBarrierOption;


using QuantLib::PlainVanillaPayoff;
using QuantLib::PercentageStrikePayoff;
using QuantLib::CashOrNothingPayoff;
using QuantLib::AssetOrNothingPayoff;
using QuantLib::SuperSharePayoff;
using QuantLib::GapPayoff;
using QuantLib::VanillaForwardPayoff;


    const ext::shared_ptr<PlainVanillaPayoff> as_plain_vanilla_payoff(
                           const ext::shared_ptr<Payoff>& payoff) {
        return ext::dynamic_pointer_cast<PlainVanillaPayoff>(payoff);
    }


using QuantLib::BasketOption;
using QuantLib::BasketPayoff;
using QuantLib::MinBasketPayoff;
using QuantLib::MaxBasketPayoff;
using QuantLib::AverageBasketPayoff;
using QuantLib::SpreadBasketPayoff;


using QuantLib::MCEuropeanBasketEngine;
using QuantLib::MCAmericanBasketEngine;

SWIGINTERN MCEuropeanBasketEngine< PseudoRandom > *new_MCEuropeanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< StochasticProcessArray > const &process,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){
            return new MCEuropeanBasketEngine<PseudoRandom>(process,
                                                   timeSteps,
                                                   timeStepsPerYear,
                                                   brownianBridge,
                                                   antitheticVariate,
                                                   requiredSamples,
                                                   requiredTolerance,
                                                   maxSamples,
                                                   seed);
        }
SWIGINTERN MCEuropeanBasketEngine< LowDiscrepancy > *new_MCEuropeanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< StochasticProcessArray > const &process,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){
            return new MCEuropeanBasketEngine<LowDiscrepancy>(process,
                                                   timeSteps,
                                                   timeStepsPerYear,
                                                   brownianBridge,
                                                   antitheticVariate,
                                                   requiredSamples,
                                                   requiredTolerance,
                                                   maxSamples,
                                                   seed);
        }
SWIGINTERN MCAmericanBasketEngine< PseudoRandom > *new_MCAmericanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< StochasticProcessArray > const &process,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,Size nCalibrationSamples=Null< Size >(),Size polynomOrder=2,LsmBasisSystem::PolynomialType polynomType=LsmBasisSystem::Monomial){
            return new MCAmericanBasketEngine<PseudoRandom>(process,
                                                   timeSteps,
                                                   timeStepsPerYear,
                                                   brownianBridge,
                                                   antitheticVariate,
                                                   requiredSamples,
                                                   requiredTolerance,
                                                   maxSamples,
                                                   seed,
                                                   nCalibrationSamples,
                                                   polynomOrder,
                                                   polynomType);
        }
SWIGINTERN MCAmericanBasketEngine< LowDiscrepancy > *new_MCAmericanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< StochasticProcessArray > const &process,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,Size nCalibrationSamples=Null< Size >(),Size polynomOrder=2,LsmBasisSystem::PolynomialType polynomType=LsmBasisSystem::Monomial){
            return new MCAmericanBasketEngine<LowDiscrepancy>(process,
                                                   timeSteps,
                                                   timeStepsPerYear,
                                                   brownianBridge,
                                                   antitheticVariate,
                                                   requiredSamples,
                                                   requiredTolerance,
                                                   maxSamples,
                                                   seed,
                                                   nCalibrationSamples,
                                                   polynomOrder,
                                                   polynomType);
        }

using QuantLib::StulzEngine;
using QuantLib::KirkEngine;
using QuantLib::Fd2dBlackScholesVanillaEngine;


using QuantLib::EverestOption;
using QuantLib::MCEverestEngine;

SWIGINTERN MCEverestEngine< PseudoRandom > *new_MCEverestEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< StochasticProcessArray > const &process,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){
            return new MCEverestEngine<PseudoRandom>(process,
                                            timeSteps,
                                            timeStepsPerYear,
                                            brownianBridge,
                                            antitheticVariate,
                                            requiredSamples,
                                            requiredTolerance,
                                            maxSamples,
                                            seed);
        }
SWIGINTERN MCEverestEngine< LowDiscrepancy > *new_MCEverestEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< StochasticProcessArray > const &process,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){
            return new MCEverestEngine<LowDiscrepancy>(process,
                                            timeSteps,
                                            timeStepsPerYear,
                                            brownianBridge,
                                            antitheticVariate,
                                            requiredSamples,
                                            requiredTolerance,
                                            maxSamples,
                                            seed);
        }

using QuantLib::HimalayaOption;
using QuantLib::MCHimalayaEngine;

SWIGINTERN MCHimalayaEngine< PseudoRandom > *new_MCHimalayaEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< StochasticProcessArray > const &process,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCHimalayaEngine<PseudoRandom>(process,
                                             brownianBridge,
                                             antitheticVariate,
                                             requiredSamples,
                                             requiredTolerance,
                                             maxSamples,
                                             seed);
        }
SWIGINTERN MCHimalayaEngine< LowDiscrepancy > *new_MCHimalayaEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< StochasticProcessArray > const &process,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCHimalayaEngine<LowDiscrepancy>(process,
                                             brownianBridge,
                                             antitheticVariate,
                                             requiredSamples,
                                             requiredTolerance,
                                             maxSamples,
                                             seed);
        }

using QuantLib::blackFormula;
using QuantLib::blackFormulaImpliedStdDev;
using QuantLib::blackFormulaImpliedStdDevLiRS;
using QuantLib::blackFormulaCashItmProbability;
using QuantLib::blackFormulaAssetItmProbability;
using QuantLib::bachelierBlackFormula;
using QuantLib::bachelierBlackFormulaImpliedVol;
using QuantLib::bachelierBlackFormulaAssetItmProbability;


using QuantLib::BlackDeltaCalculator;


using QuantLib::TimeBasket;


using QuantLib::Swap;
using QuantLib::VanillaSwap;
using QuantLib::MakeVanillaSwap;
using QuantLib::NonstandardSwap;
using QuantLib::DiscountingSwapEngine;
using QuantLib::FloatFloatSwap;
using QuantLib::OvernightIndexedSwap;
using QuantLib::MakeOIS;
using QuantLib::ZeroCouponSwap;
using QuantLib::EquityTotalReturnSwap;
using QuantLib::ArithmeticAverageOIS;
using QuantLib::simplifyNotificationGraph;

SWIGINTERN VanillaSwap *new_VanillaSwap__SWIG_0(Swap::Type type,Real nominal,Schedule const &fixedSchedule,Rate fixedRate,DayCounter const &fixedDayCount,Schedule const &floatSchedule,ext::shared_ptr< IborIndex > const &index,Spread spread,DayCounter const &floatingDayCount,ext::optional< bool > withIndexedCoupons=ext::nullopt){
            // work around the lack of typemap for this argument
            ext::optional<BusinessDayConvention> paymentConvention = ext::nullopt;

            return new VanillaSwap(type, nominal, fixedSchedule, fixedRate, fixedDayCount,
                                   floatSchedule, index, spread, floatingDayCount,
                                   paymentConvention, withIndexedCoupons);
        }
SWIGINTERN ext::shared_ptr< VanillaSwap > MakeVanillaSwap_makeVanillaSwap(MakeVanillaSwap *self){
                return (ext::shared_ptr<VanillaSwap>)(* self);
            }
SWIGINTERN DiscountingSwapEngine *new_DiscountingSwapEngine__SWIG_3(Handle< YieldTermStructure > const &discountCurve,Date const &settlementDate=Date(),Date const &npvDate=Date()){
            return new DiscountingSwapEngine(discountCurve,
                                             ext::nullopt,
                                             settlementDate,
                                             npvDate);
        }

using QuantLib::AssetSwap;
using QuantLib::OvernightIndexedSwapIndex;

SWIGINTERN ext::shared_ptr< OvernightIndexedSwap > MakeOIS_makeOIS(MakeOIS *self){
                return (ext::shared_ptr<OvernightIndexedSwap>)(* self);
            }

    ext::shared_ptr<OvernightIndexedSwap> as_overnight_swap_index(
                          const ext::shared_ptr<InterestRateIndex>& index) {
        return ext::dynamic_pointer_cast<OvernightIndexedSwap>(index);
    }


  using QuantLib::InflationTermStructure;
  using QuantLib::Seasonality;
  using QuantLib::MultiplicativePriceSeasonality;
  using QuantLib::KerkhofSeasonality;


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

SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_YoYInflationTermStructure_Sg__asObservable(Handle< YoYInflationTermStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_YoYInflationTermStructure_Sg__reset(RelinkableHandle< YoYInflationTermStructure > *self){
            self->linkTo(ext::shared_ptr<YoYInflationTermStructure>());
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_ZeroInflationTermStructure_Sg__asObservable(Handle< ZeroInflationTermStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_ZeroInflationTermStructure_Sg__reset(RelinkableHandle< ZeroInflationTermStructure > *self){
            self->linkTo(ext::shared_ptr<ZeroInflationTermStructure>());
        }

using QuantLib::Region;
using QuantLib::CustomRegion;
using QuantLib::InflationIndex;
using QuantLib::ZeroInflationIndex;
using QuantLib::YoYInflationIndex;


    ext::shared_ptr<ZeroInflationIndex> as_zero_inflation_index(const ext::shared_ptr<Index>& i) {
        return ext::dynamic_pointer_cast<ZeroInflationIndex>(i);
    }


using QuantLib::EUHICP;


using QuantLib::EUHICPXT;


using QuantLib::FRHICP;


using QuantLib::UKRPI;


using QuantLib::USCPI;


using QuantLib::ZACPI;


using QuantLib::UKHICP;


using QuantLib::YYEUHICP;


using QuantLib::YYEUHICPXT;


using QuantLib::YYEUHICPr;


using QuantLib::YYFRHICP;


using QuantLib::YYFRHICPr;


using QuantLib::YYUKRPI;


using QuantLib::YYUKRPIr;


using QuantLib::YYUSCPI;


using QuantLib::YYUSCPIr;


using QuantLib::YYZACPI;


using QuantLib::YYZACPIr;


using QuantLib::AUCPI;


using QuantLib::CPI;


using QuantLib::InflationCoupon;
using QuantLib::CPICoupon;
using QuantLib::CPICouponPricer;
using QuantLib::CPICashFlow;
using QuantLib::ZeroInflationCashFlow;


    ext::shared_ptr<InflationCoupon> as_inflation_coupon(
                                      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<InflationCoupon>(cf);
    }


    ext::shared_ptr<CPICoupon> as_cpi_coupon(
                                      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<CPICoupon>(cf);
    }


    ext::shared_ptr<CPICashFlow> as_cpi_cashflow(
                                      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<CPICashFlow>(cf);
    }


Leg _CPILeg(const std::vector<Real>& nominals,
            const Schedule& schedule,
            const ext::shared_ptr<ZeroInflationIndex>& index,
            Real baseCPI,
            const Period& observationLag,
            const DayCounter& paymentDayCounter = DayCounter(),
            const BusinessDayConvention paymentConvention = Following,
            const std::vector<Real>& fixedRates = 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>(),
            const Period& exCouponPeriod = Period(),
            const Calendar& exCouponCalendar = Calendar(),
            BusinessDayConvention exCouponConvention = Unadjusted,
            bool exCouponEndOfMonth = false,
            const Calendar& paymentCalendar = Calendar(),
            bool growthOnly = true,
            CPI::InterpolationType observationInterpolation = CPI::AsIndex) {
    return QuantLib::CPILeg(schedule, index, baseCPI, observationLag)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withPaymentCalendar(paymentCalendar.empty() ? schedule.calendar() : paymentCalendar)
        .withFixedRates(fixedRates)
        .withSpreads(spreads)
        .withCaps(caps)
        .withFloors(floors)
        .withExCouponPeriod(exCouponPeriod,
                            exCouponCalendar,
                            exCouponConvention,
                            exCouponEndOfMonth)
        .withSubtractInflationNominal(growthOnly)
        .withObservationInterpolation(observationInterpolation);
}


    ext::shared_ptr<ZeroInflationCashFlow> as_zero_inflation_cash_flow(
                                      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<ZeroInflationCashFlow>(cf);
    }


using QuantLib::BootstrapHelper;
using QuantLib::ZeroCouponInflationSwapHelper;
using QuantLib::YearOnYearInflationSwapHelper;
using QuantLib::YoYOptionletHelper;

SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *new_std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<BootstrapHelper<ZeroInflationTermStructure> > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<BootstrapHelper<ZeroInflationTermStructure> > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__getitem(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *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_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__setitem(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,int index,ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__AddRange(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__GetRange(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *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< ext::shared_ptr<BootstrapHelper<ZeroInflationTermStructure> > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__Insert(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,int index,ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > 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_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__InsertRange(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,int index,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > 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_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__RemoveAt(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *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_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__RemoveRange(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *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< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__Repeat(ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<BootstrapHelper<ZeroInflationTermStructure> > >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__Reverse__SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *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_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__SetRange(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,int index,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > 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_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__Contains(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__IndexOf(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<BootstrapHelper<ZeroInflationTermStructure> > >::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_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<BootstrapHelper<ZeroInflationTermStructure> > >::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_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__Remove(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > const &value){
        std::vector< ext::shared_ptr<BootstrapHelper<ZeroInflationTermStructure> > >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *new_std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<BootstrapHelper<YoYInflationTermStructure> > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<BootstrapHelper<YoYInflationTermStructure> > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__getitem(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *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_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__setitem(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,int index,ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__AddRange(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__GetRange(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *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< ext::shared_ptr<BootstrapHelper<YoYInflationTermStructure> > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__Insert(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,int index,ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > 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_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__InsertRange(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,int index,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > 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_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__RemoveAt(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *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_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__RemoveRange(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *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< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__Repeat(ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<BootstrapHelper<YoYInflationTermStructure> > >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__Reverse__SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *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_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__SetRange(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,int index,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > 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_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__Contains(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__IndexOf(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<BootstrapHelper<YoYInflationTermStructure> > >::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_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<BootstrapHelper<YoYInflationTermStructure> > >::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_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__Remove(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > const &value){
        std::vector< ext::shared_ptr<BootstrapHelper<YoYInflationTermStructure> > >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *new_std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<BootstrapHelper<YoYOptionletVolatilitySurface> > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<BootstrapHelper<YoYOptionletVolatilitySurface> > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__getitem(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *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_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__setitem(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,int index,ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__AddRange(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__GetRange(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *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< ext::shared_ptr<BootstrapHelper<YoYOptionletVolatilitySurface> > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__Insert(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,int index,ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > 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_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__InsertRange(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,int index,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > 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_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__RemoveAt(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *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_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__RemoveRange(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *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< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__Repeat(ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<BootstrapHelper<YoYOptionletVolatilitySurface> > >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__Reverse__SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *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_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__SetRange(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,int index,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > 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_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__Contains(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__IndexOf(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<BootstrapHelper<YoYOptionletVolatilitySurface> > >::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_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<BootstrapHelper<YoYOptionletVolatilitySurface> > >::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_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__Remove(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > const &value){
        std::vector< ext::shared_ptr<BootstrapHelper<YoYOptionletVolatilitySurface> > >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }

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


using QuantLib::inflationPeriod;
using QuantLib::inflationYearFraction;



    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::YoYInflationCoupon;
using QuantLib::CappedFlooredYoYInflationCoupon;
using QuantLib::YoYInflationCouponPricer;
using QuantLib::setCouponPricer;
using QuantLib::BlackYoYInflationCouponPricer;
using QuantLib::UnitDisplacedBlackYoYInflationCouponPricer;
using QuantLib::BachelierYoYInflationCouponPricer;


    ext::shared_ptr<YoYInflationCoupon> as_yoy_inflation_coupon(
                                      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<YoYInflationCoupon>(cf);
    }


    ext::shared_ptr<CappedFlooredYoYInflationCoupon> as_capped_floored_yoy_inflation_coupon(
                                      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<CappedFlooredYoYInflationCoupon>(cf);
    }


Leg _yoyInflationLeg(const Schedule& schedule,
                     const Calendar& calendar,
                     const ext::shared_ptr<YoYInflationIndex>& index,
                     const Period& observationLag,
                     const std::vector<Real>& notionals,
                     const DayCounter& paymentDayCounter,
                     BusinessDayConvention paymentAdjustment = Following,
                     Natural fixingDays = 0,
                     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>()) {
        return QuantLib::yoyInflationLeg(schedule, calendar, index, observationLag)
            .withNotionals(notionals)
            .withPaymentDayCounter(paymentDayCounter)
            .withPaymentAdjustment(paymentAdjustment)
            .withFixingDays(fixingDays)
            .withGearings(gearings)
            .withSpreads(spreads)
            .withCaps(caps)
            .withFloors(floors);
}


using QuantLib::ZeroCouponInflationSwap;
using QuantLib::YearOnYearInflationSwap;
using QuantLib::CPISwap;


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

SWIGINTERN std::vector< Real > YoYInflationCapFloor_optionletPrices(YoYInflationCapFloor *self){
             return self->result<std::vector<Real> >("optionletsPrice");
         }

using QuantLib::InterpolatedZeroInflationCurve;
using QuantLib::InterpolatedYoYInflationCurve;


using QuantLib::YoYCapFloorTermPriceSurface;
using QuantLib::InterpolatedYoYCapFloorTermPriceSurface;


typedef InterpolatedYoYCapFloorTermPriceSurface<Bicubic, Cubic> YoYInflationCapFloorTermPriceSurface;

SWIGINTERN YoYInflationCapFloorTermPriceSurface *new_YoYInflationCapFloorTermPriceSurface__SWIG_0(Natural fixingDays,Period const &yyLag,ext::shared_ptr< YoYInflationIndex > const &yii,Rate baseRate,Handle< YieldTermStructure > const &nominal,DayCounter const &dc,Calendar const &cal,BusinessDayConvention const &bdc,std::vector< Rate > const &cStrikes,std::vector< Rate > const &fStrikes,std::vector< Period > const &cfMaturities,Matrix const &cPrice,Matrix const &fPrice,Bicubic const &interpolator2d=Bicubic(),Cubic const &interpolator1d=Cubic()){
            return new YoYInflationCapFloorTermPriceSurface(fixingDays, yyLag, yii, baseRate, nominal,
                            dc, cal, bdc, cStrikes, fStrikes, cfMaturities,
                            cPrice, fPrice);
        }

using QuantLib::YoYInflationCapFloorEngine;
using QuantLib::YoYInflationBlackCapFloorEngine;
using QuantLib::YoYInflationUnitDisplacedBlackCapFloorEngine;
using QuantLib::YoYInflationBachelierCapFloorEngine;

SWIGINTERN YoYOptionletHelper *new_YoYOptionletHelper(Handle< Quote > const &price,Real notional,YoYInflationCapFloor::Type capFloorType,Period &lag,DayCounter const &yoyDayCounter,Calendar const &paymentCalendar,Natural fixingDays,ext::shared_ptr< YoYInflationIndex > const &index,Rate strike,Size n,ext::shared_ptr< PricingEngine > const &pricer){
            ext::shared_ptr<QuantLib::YoYInflationCapFloorEngine> engine = ext::dynamic_pointer_cast<YoYInflationCapFloorEngine>(pricer);
            return new YoYOptionletHelper(price, notional, capFloorType, lag, yoyDayCounter, paymentCalendar, fixingDays, index, strike, n, engine);
         }

using QuantLib::YoYOptionletStripper;
using QuantLib::InterpolatedYoYOptionletStripper;

SWIGINTERN void YoYOptionletStripper_initialize(YoYOptionletStripper const *self,ext::shared_ptr< YoYCapFloorTermPriceSurface > const &surf,ext::shared_ptr< PricingEngine > const &pricer,Real slope){
            ext::shared_ptr<QuantLib::YoYInflationCapFloorEngine> engine = ext::dynamic_pointer_cast<YoYInflationCapFloorEngine>(pricer);
            return (self)->initialize(surf, engine, slope);
        }

using QuantLib::InterpolatedYoYOptionletVolatilityCurve;
using QuantLib::KInterpolatedYoYOptionletVolatilitySurface;
using QuantLib::YoYInflationCapFloorEngine;

SWIGINTERN KInterpolatedYoYOptionletVolatilitySurface< Linear > *new_KInterpolatedYoYOptionletVolatilitySurface_Sl_Linear_Sg___SWIG_0(Natural settlementDays,Calendar const &calendar,BusinessDayConvention bdc,DayCounter const &dc,Period const &lag,ext::shared_ptr< YoYCapFloorTermPriceSurface > const &capFloorPrices,ext::shared_ptr< PricingEngine > const &pricer,ext::shared_ptr< YoYOptionletStripper > const &yoyOptionletStripper,Real slope,Linear const &interpolator=Linear()){
                 ext::shared_ptr<QuantLib::YoYInflationCapFloorEngine> engine = ext::dynamic_pointer_cast<YoYInflationCapFloorEngine>(pricer);
                     return new KInterpolatedYoYOptionletVolatilitySurface<Linear>(settlementDays,
                                 calendar, bdc, dc, lag, capFloorPrices, engine, yoyOptionletStripper,
                                 slope, interpolator);
        }

using QuantLib::ShortRateModel;

SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_ShortRateModel_Sg__asObservable(Handle< ShortRateModel > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_ShortRateModel_Sg__reset(RelinkableHandle< ShortRateModel > *self){
            self->linkTo(ext::shared_ptr<ShortRateModel>());
        }

using QuantLib::OneFactorAffineModel;
using QuantLib::Vasicek;
using QuantLib::HullWhite;
using QuantLib::BlackKarasinski;
using QuantLib::G2;
using QuantLib::CoxIngersollRoss;
using QuantLib::ExtendedCoxIngersollRoss;


using QuantLib::JamshidianSwaptionEngine;
using QuantLib::TreeSwaptionEngine;
using QuantLib::AnalyticCapFloorEngine;
using QuantLib::TreeCapFloorEngine;
using QuantLib::G2SwaptionEngine;
using QuantLib::FdG2SwaptionEngine;
using QuantLib::FdHullWhiteSwaptionEngine;


using QuantLib::AnalyticBSMHullWhiteEngine;


using QuantLib::Bond;
typedef Bond::Price BondPrice;
using QuantLib::ZeroCouponBond;
using QuantLib::FixedRateBond;
using QuantLib::AmortizingFixedRateBond;
using QuantLib::FloatingRateBond;
using QuantLib::AmortizingFloatingRateBond;
using QuantLib::DiscountingBondEngine;
using QuantLib::simplifyNotificationGraph;


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



using QuantLib::CmsRateBond;
using QuantLib::AmortizingCmsRateBond;


using QuantLib::CallableBond;
using QuantLib::Callability;
using QuantLib::SoftCallability;
using QuantLib::CallabilitySchedule;

using QuantLib::CallableFixedRateBond;
using QuantLib::CallableZeroCouponBond;
using QuantLib::TreeCallableFixedRateBondEngine;
using QuantLib::BlackCallableFixedRateBondEngine;

SWIGINTERN std::vector< ext::shared_ptr< Callability > > *new_std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<Callability> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<Callability> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< Callability > std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< Callability > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< Callability > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__getitem(std::vector< ext::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_ext_shared_ptr_Sl_Callability_Sg__Sg__setitem(std::vector< ext::shared_ptr< Callability > > *self,int index,ext::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_ext_shared_ptr_Sl_Callability_Sg__Sg__AddRange(std::vector< ext::shared_ptr< Callability > > *self,std::vector< ext::shared_ptr< Callability > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< Callability > > *std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__GetRange(std::vector< ext::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< ext::shared_ptr<Callability> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__Insert(std::vector< ext::shared_ptr< Callability > > *self,int index,ext::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_ext_shared_ptr_Sl_Callability_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< Callability > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_Callability_Sg__Sg__RemoveAt(std::vector< ext::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_ext_shared_ptr_Sl_Callability_Sg__Sg__RemoveRange(std::vector< ext::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< ext::shared_ptr< Callability > > *std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__Repeat(ext::shared_ptr< Callability > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<Callability> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< Callability > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__Reverse__SWIG_1(std::vector< ext::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_ext_shared_ptr_Sl_Callability_Sg__Sg__SetRange(std::vector< ext::shared_ptr< Callability > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_Callability_Sg__Sg__Contains(std::vector< ext::shared_ptr< Callability > > *self,ext::shared_ptr< Callability > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< Callability > > *self,ext::shared_ptr< Callability > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_Callability_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< Callability > > *self,ext::shared_ptr< Callability > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_Callability_Sg__Sg__Remove(std::vector< ext::shared_ptr< Callability > > *self,ext::shared_ptr< Callability > const &value){
        std::vector< ext::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::CPIBond;


using QuantLib::BondFunctions;

SWIGINTERN Rate BondFunctions_yieldBrent__SWIG_0(Brent solver,Bond 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,
                        bond,
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }
SWIGINTERN Rate BondFunctions_yieldBisection__SWIG_0(Bisection solver,Bond 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,
                        bond,
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }
SWIGINTERN Rate BondFunctions_yieldFalsePosition__SWIG_0(FalsePosition solver,Bond 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,
                        bond,
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }
SWIGINTERN Rate BondFunctions_yieldRidder__SWIG_0(Ridder solver,Bond 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,
                        bond,
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }
SWIGINTERN Rate BondFunctions_yieldSecant__SWIG_0(Secant solver,Bond 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,
                        bond,
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }

using QuantLib::VanillaSwap;
using QuantLib::Swaption;
using QuantLib::BlackCalibrationHelper;
using QuantLib::SwaptionHelper;
using QuantLib::CapHelper;
using QuantLib::HestonModelHelper;


    ext::shared_ptr<BlackCalibrationHelper> as_black_helper(const ext::shared_ptr<CalibrationHelper>& h) {
        return ext::dynamic_pointer_cast<BlackCalibrationHelper>(h);
    }
    ext::shared_ptr<SwaptionHelper> as_swaption_helper(const ext::shared_ptr<BlackCalibrationHelper>& h) {
        return ext::dynamic_pointer_cast<SwaptionHelper>(h);
    }

SWIGINTERN std::vector< Time > SwaptionHelper_times(SwaptionHelper *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 Date SwaptionHelper_swaptionExpiryDate(SwaptionHelper *self){
            return self->swaption()->exercise()->date(0);
        }
SWIGINTERN Real SwaptionHelper_swaptionStrike(SwaptionHelper *self){
            return self->swaption()->underlyingSwap()->fixedRate();
        }
SWIGINTERN Real SwaptionHelper_swaptionNominal(SwaptionHelper *self){
            return self->swaption()->underlyingSwap()->nominal();
        }
SWIGINTERN Date SwaptionHelper_swaptionMaturityDate(SwaptionHelper *self){
            return self->swaption()->underlyingSwap()->fixedSchedule().dates().back();
        }
SWIGINTERN std::vector< Time > CapHelper_times(CapHelper *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 std::vector< ext::shared_ptr< BlackCalibrationHelper > > *new_std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<BlackCalibrationHelper> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<BlackCalibrationHelper> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< BlackCalibrationHelper > std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__getitem(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *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_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__setitem(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,int index,ext::shared_ptr< BlackCalibrationHelper > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__AddRange(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,std::vector< ext::shared_ptr< BlackCalibrationHelper > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< BlackCalibrationHelper > > *std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__GetRange(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *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< ext::shared_ptr<BlackCalibrationHelper> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__Insert(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,int index,ext::shared_ptr< BlackCalibrationHelper > 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_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,int index,std::vector< ext::shared_ptr< BlackCalibrationHelper > > 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_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__RemoveAt(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *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_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__RemoveRange(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *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< ext::shared_ptr< BlackCalibrationHelper > > *std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__Repeat(ext::shared_ptr< BlackCalibrationHelper > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<BlackCalibrationHelper> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__Reverse__SWIG_1(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *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_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__SetRange(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,int index,std::vector< ext::shared_ptr< BlackCalibrationHelper > > 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_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__Contains(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,ext::shared_ptr< BlackCalibrationHelper > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,ext::shared_ptr< BlackCalibrationHelper > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<BlackCalibrationHelper> >::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_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,ext::shared_ptr< BlackCalibrationHelper > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<BlackCalibrationHelper> >::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_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__Remove(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,ext::shared_ptr< BlackCalibrationHelper > const &value){
        std::vector< ext::shared_ptr<BlackCalibrationHelper> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }

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

SWIGINTERN Real const CapFloor_vega(CapFloor *self){
        return self->result<Real>("vega");
      }
SWIGINTERN std::vector< Real > const CapFloor_optionletsPrice(CapFloor *self){
        return self->result<std::vector<Real> >("optionletsPrice");
      }
SWIGINTERN std::vector< Real > const CapFloor_optionletsVega(CapFloor *self){
        return self->result<std::vector<Real> >("optionletsVega");
      }
SWIGINTERN std::vector< Real > const CapFloor_optionletsDelta(CapFloor *self){
        return self->result<std::vector<Real> >("optionletsDelta");
      }
SWIGINTERN std::vector< DiscountFactor > const CapFloor_optionletsDiscountFactor(CapFloor *self){
        return self->result<std::vector<DiscountFactor> >("optionletsDiscountFactor");
      }
SWIGINTERN std::vector< Rate > const CapFloor_optionletsAtmForward(CapFloor *self){
        return self->result<std::vector<Real> >("optionletsAtmForward");
      }
SWIGINTERN std::vector< Rate > const CapFloor_optionletsStdDev(CapFloor *self){
        return self->result<std::vector<Real> >("optionletsStdDev");
      }

using QuantLib::BlackCapFloorEngine;


using QuantLib::BachelierCapFloorEngine;


using QuantLib::CliquetOption;


using QuantLib::AnalyticCliquetEngine;
using QuantLib::AnalyticPerformanceEngine;
using QuantLib::MCPerformanceEngine;

SWIGINTERN MCPerformanceEngine< PseudoRandom > *new_MCPerformanceEngine_Sl_PseudoRandom_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > process,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCPerformanceEngine<PseudoRandom>(process,
                                                brownianBridge,
                                                antitheticVariate,
                                                requiredSamples,
                                                requiredTolerance,
                                                maxSamples,
                                                seed);
        }
SWIGINTERN MCPerformanceEngine< LowDiscrepancy > *new_MCPerformanceEngine_Sl_LowDiscrepancy_Sg___SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > process,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCPerformanceEngine<LowDiscrepancy>(process,
                                                brownianBridge,
                                                antitheticVariate,
                                                requiredSamples,
                                                requiredTolerance,
                                                maxSamples,
                                                seed);
        }

using QuantLib::ConvertibleZeroCouponBond;
using QuantLib::ConvertibleFixedCouponBond;
using QuantLib::ConvertibleFloatingRateBond;
using QuantLib::BinomialConvertibleEngine;


using QuantLib::Forward;


using QuantLib::BondForward;
using QuantLib::FixedRateBondForward;
using QuantLib::FixedRateBond;
using QuantLib::BusinessDayConvention;
using QuantLib::Position;


using QuantLib::Futures;
using QuantLib::OvernightIndexFuture;


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;
using QuantLib::OvernightIndexFutureRateHelper;
using QuantLib::SofrFutureRateHelper;
using QuantLib::ConstNotionalCrossCurrencyBasisSwapRateHelper;
using QuantLib::MtMCrossCurrencyBasisSwapRateHelper;
using QuantLib::IborIborBasisSwapRateHelper;
using QuantLib::OvernightIborBasisSwapRateHelper;
using QuantLib::ArithmeticOISRateHelper;

SWIGINTERN std::vector< ext::shared_ptr< RateHelper > > *new_std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<RateHelper> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<RateHelper> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< RateHelper > std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< RateHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< RateHelper > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__getitem(std::vector< ext::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_ext_shared_ptr_Sl_RateHelper_Sg__Sg__setitem(std::vector< ext::shared_ptr< RateHelper > > *self,int index,ext::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_ext_shared_ptr_Sl_RateHelper_Sg__Sg__AddRange(std::vector< ext::shared_ptr< RateHelper > > *self,std::vector< ext::shared_ptr< RateHelper > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< RateHelper > > *std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__GetRange(std::vector< ext::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< ext::shared_ptr<RateHelper> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__Insert(std::vector< ext::shared_ptr< RateHelper > > *self,int index,ext::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_ext_shared_ptr_Sl_RateHelper_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< RateHelper > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_RateHelper_Sg__Sg__RemoveAt(std::vector< ext::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_ext_shared_ptr_Sl_RateHelper_Sg__Sg__RemoveRange(std::vector< ext::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< ext::shared_ptr< RateHelper > > *std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__Repeat(ext::shared_ptr< RateHelper > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<RateHelper> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< RateHelper > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__Reverse__SWIG_1(std::vector< ext::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_ext_shared_ptr_Sl_RateHelper_Sg__Sg__SetRange(std::vector< ext::shared_ptr< RateHelper > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_RateHelper_Sg__Sg__Contains(std::vector< ext::shared_ptr< RateHelper > > *self,ext::shared_ptr< RateHelper > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< RateHelper > > *self,ext::shared_ptr< RateHelper > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_RateHelper_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< RateHelper > > *self,ext::shared_ptr< RateHelper > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_RateHelper_Sg__Sg__Remove(std::vector< ext::shared_ptr< RateHelper > > *self,ext::shared_ptr< RateHelper > const &value){
        std::vector< ext::shared_ptr<RateHelper> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< ext::shared_ptr< BondHelper > > *new_std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<BondHelper> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<BondHelper> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< BondHelper > std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< BondHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< BondHelper > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__getitem(std::vector< ext::shared_ptr< BondHelper > > *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_ext_shared_ptr_Sl_BondHelper_Sg__Sg__setitem(std::vector< ext::shared_ptr< BondHelper > > *self,int index,ext::shared_ptr< BondHelper > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__AddRange(std::vector< ext::shared_ptr< BondHelper > > *self,std::vector< ext::shared_ptr< BondHelper > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< BondHelper > > *std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__GetRange(std::vector< ext::shared_ptr< BondHelper > > *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< ext::shared_ptr<BondHelper> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__Insert(std::vector< ext::shared_ptr< BondHelper > > *self,int index,ext::shared_ptr< BondHelper > 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_ext_shared_ptr_Sl_BondHelper_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< BondHelper > > *self,int index,std::vector< ext::shared_ptr< BondHelper > > 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_ext_shared_ptr_Sl_BondHelper_Sg__Sg__RemoveAt(std::vector< ext::shared_ptr< BondHelper > > *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_ext_shared_ptr_Sl_BondHelper_Sg__Sg__RemoveRange(std::vector< ext::shared_ptr< BondHelper > > *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< ext::shared_ptr< BondHelper > > *std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__Repeat(ext::shared_ptr< BondHelper > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<BondHelper> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< BondHelper > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__Reverse__SWIG_1(std::vector< ext::shared_ptr< BondHelper > > *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_ext_shared_ptr_Sl_BondHelper_Sg__Sg__SetRange(std::vector< ext::shared_ptr< BondHelper > > *self,int index,std::vector< ext::shared_ptr< BondHelper > > 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_ext_shared_ptr_Sl_BondHelper_Sg__Sg__Contains(std::vector< ext::shared_ptr< BondHelper > > *self,ext::shared_ptr< BondHelper > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< BondHelper > > *self,ext::shared_ptr< BondHelper > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<BondHelper> >::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_ext_shared_ptr_Sl_BondHelper_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< BondHelper > > *self,ext::shared_ptr< BondHelper > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<BondHelper> >::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_ext_shared_ptr_Sl_BondHelper_Sg__Sg__Remove(std::vector< ext::shared_ptr< BondHelper > > *self,ext::shared_ptr< BondHelper > const &value){
        std::vector< ext::shared_ptr<BondHelper> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }

    const ext::shared_ptr<DepositRateHelper> as_depositratehelper(const ext::shared_ptr<RateHelper> helper) {
        return ext::dynamic_pointer_cast<DepositRateHelper>(helper);
    }
	const ext::shared_ptr<FraRateHelper> as_fraratehelper(const ext::shared_ptr<RateHelper> helper) {
        return ext::dynamic_pointer_cast<FraRateHelper>(helper);
    }
    const ext::shared_ptr<SwapRateHelper> as_swapratehelper(const ext::shared_ptr<RateHelper> helper) {
        return ext::dynamic_pointer_cast<SwapRateHelper>(helper);
    }
    const ext::shared_ptr<OISRateHelper> as_oisratehelper(const ext::shared_ptr<RateHelper> helper) {
        return ext::dynamic_pointer_cast<OISRateHelper>(helper);
    }
    const ext::shared_ptr<ConstNotionalCrossCurrencyBasisSwapRateHelper> as_constnotionalcrosscurrencybasisswapratehelper(
            const ext::shared_ptr<RateHelper> helper) {
        return ext::dynamic_pointer_cast<ConstNotionalCrossCurrencyBasisSwapRateHelper>(helper);
    }
    const ext::shared_ptr<MtMCrossCurrencyBasisSwapRateHelper> as_mtmcrosscurrencybasisswapratehelper(
            const ext::shared_ptr<RateHelper> helper) {
        return ext::dynamic_pointer_cast<MtMCrossCurrencyBasisSwapRateHelper>(helper);
    }


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


using QuantLib::PiecewiseYieldCurve;


struct _IterativeBootstrap {
    double accuracy, minValue, maxValue;
    Size maxAttempts;
    Real maxFactor, minFactor;
    bool dontThrow;
    Size dontThrowSteps, maxEvaluations;
    _IterativeBootstrap(double accuracy = Null<double>(),
                        double minValue = Null<double>(),
                        double maxValue = Null<double>(),
                        Size maxAttempts = 1,
                        Real maxFactor = 2.0,
                        Real minFactor = 2.0,
                        bool dontThrow = false,
                        Size dontThrowSteps = 10,
                        Size maxEvaluations = 100)
    : accuracy(accuracy), minValue(minValue), maxValue(maxValue),
      maxAttempts(maxAttempts), maxFactor(maxFactor), minFactor(minFactor),
      dontThrow(dontThrow), dontThrowSteps(dontThrowSteps),
      maxEvaluations(maxEvaluations) {}
};

template <class PiecewiseYieldCurve>
inline typename PiecewiseYieldCurve::bootstrap_type make_bootstrap(const _IterativeBootstrap& b) {
    return {
        b.accuracy, b.minValue, b.maxValue,
        b.maxAttempts, b.maxFactor, b.minFactor,
        b.dontThrow, b.dontThrowSteps,
        b.maxEvaluations
    };
}


typedef PiecewiseYieldCurve<ForwardRate, BackwardFlat> PiecewiseFlatForward;

SWIGINTERN PiecewiseFlatForward *new_PiecewiseFlatForward__SWIG_0(Date const &referenceDate,std::vector< ext::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 >(),BackwardFlat const &i=BackwardFlat(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseFlatForward(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseFlatForward>(b));
        }
SWIGINTERN PiecewiseFlatForward *new_PiecewiseFlatForward__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::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 >(),BackwardFlat const &i=BackwardFlat(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseFlatForward(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseFlatForward>(b));
        }
SWIGINTERN PiecewiseFlatForward *new_PiecewiseFlatForward__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,BackwardFlat const &i=BackwardFlat()){
            return new PiecewiseFlatForward(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseFlatForward>(b));
        }
SWIGINTERN PiecewiseFlatForward *new_PiecewiseFlatForward__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,BackwardFlat const &i=BackwardFlat()){
            return new PiecewiseFlatForward(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseFlatForward>(b));
        }

typedef PiecewiseYieldCurve<Discount, LogLinear> PiecewiseLogLinearDiscount;

SWIGINTERN PiecewiseLogLinearDiscount *new_PiecewiseLogLinearDiscount__SWIG_0(Date const &referenceDate,std::vector< ext::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 >(),LogLinear const &i=LogLinear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLogLinearDiscount(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseLogLinearDiscount>(b));
        }
SWIGINTERN PiecewiseLogLinearDiscount *new_PiecewiseLogLinearDiscount__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::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 >(),LogLinear const &i=LogLinear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLogLinearDiscount(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseLogLinearDiscount>(b));
        }
SWIGINTERN PiecewiseLogLinearDiscount *new_PiecewiseLogLinearDiscount__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,LogLinear const &i=LogLinear()){
            return new PiecewiseLogLinearDiscount(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseLogLinearDiscount>(b));
        }
SWIGINTERN PiecewiseLogLinearDiscount *new_PiecewiseLogLinearDiscount__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,LogLinear const &i=LogLinear()){
            return new PiecewiseLogLinearDiscount(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseLogLinearDiscount>(b));
        }

typedef PiecewiseYieldCurve<ForwardRate, Linear> PiecewiseLinearForward;

SWIGINTERN PiecewiseLinearForward *new_PiecewiseLinearForward__SWIG_0(Date const &referenceDate,std::vector< ext::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 >(),Linear const &i=Linear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLinearForward(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseLinearForward>(b));
        }
SWIGINTERN PiecewiseLinearForward *new_PiecewiseLinearForward__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::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 >(),Linear const &i=Linear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLinearForward(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseLinearForward>(b));
        }
SWIGINTERN PiecewiseLinearForward *new_PiecewiseLinearForward__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,Linear const &i=Linear()){
            return new PiecewiseLinearForward(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseLinearForward>(b));
        }
SWIGINTERN PiecewiseLinearForward *new_PiecewiseLinearForward__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,Linear const &i=Linear()){
            return new PiecewiseLinearForward(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseLinearForward>(b));
        }

typedef PiecewiseYieldCurve<ZeroYield, Linear> PiecewiseLinearZero;

SWIGINTERN PiecewiseLinearZero *new_PiecewiseLinearZero__SWIG_0(Date const &referenceDate,std::vector< ext::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 >(),Linear const &i=Linear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLinearZero(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseLinearZero>(b));
        }
SWIGINTERN PiecewiseLinearZero *new_PiecewiseLinearZero__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::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 >(),Linear const &i=Linear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLinearZero(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseLinearZero>(b));
        }
SWIGINTERN PiecewiseLinearZero *new_PiecewiseLinearZero__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,Linear const &i=Linear()){
            return new PiecewiseLinearZero(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseLinearZero>(b));
        }
SWIGINTERN PiecewiseLinearZero *new_PiecewiseLinearZero__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,Linear const &i=Linear()){
            return new PiecewiseLinearZero(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseLinearZero>(b));
        }

typedef PiecewiseYieldCurve<ZeroYield, Cubic> PiecewiseCubicZero;

SWIGINTERN PiecewiseCubicZero *new_PiecewiseCubicZero__SWIG_0(Date const &referenceDate,std::vector< ext::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 >(),Cubic const &i=Cubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseCubicZero(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseCubicZero>(b));
        }
SWIGINTERN PiecewiseCubicZero *new_PiecewiseCubicZero__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::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 >(),Cubic const &i=Cubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseCubicZero(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseCubicZero>(b));
        }
SWIGINTERN PiecewiseCubicZero *new_PiecewiseCubicZero__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,Cubic const &i=Cubic()){
            return new PiecewiseCubicZero(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseCubicZero>(b));
        }
SWIGINTERN PiecewiseCubicZero *new_PiecewiseCubicZero__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,Cubic const &i=Cubic()){
            return new PiecewiseCubicZero(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseCubicZero>(b));
        }

typedef PiecewiseYieldCurve<Discount, MonotonicLogCubic> PiecewiseLogCubicDiscount;

SWIGINTERN PiecewiseLogCubicDiscount *new_PiecewiseLogCubicDiscount__SWIG_0(Date const &referenceDate,std::vector< ext::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 >(),MonotonicLogCubic const &i=MonotonicLogCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLogCubicDiscount(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseLogCubicDiscount>(b));
        }
SWIGINTERN PiecewiseLogCubicDiscount *new_PiecewiseLogCubicDiscount__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::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 >(),MonotonicLogCubic const &i=MonotonicLogCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLogCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseLogCubicDiscount>(b));
        }
SWIGINTERN PiecewiseLogCubicDiscount *new_PiecewiseLogCubicDiscount__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,MonotonicLogCubic const &i=MonotonicLogCubic()){
            return new PiecewiseLogCubicDiscount(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseLogCubicDiscount>(b));
        }
SWIGINTERN PiecewiseLogCubicDiscount *new_PiecewiseLogCubicDiscount__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,MonotonicLogCubic const &i=MonotonicLogCubic()){
            return new PiecewiseLogCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseLogCubicDiscount>(b));
        }

typedef PiecewiseYieldCurve<Discount, SplineCubic> PiecewiseSplineCubicDiscount;

SWIGINTERN PiecewiseSplineCubicDiscount *new_PiecewiseSplineCubicDiscount__SWIG_0(Date const &referenceDate,std::vector< ext::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 >(),SplineCubic const &i=SplineCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseSplineCubicDiscount(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseSplineCubicDiscount>(b));
        }
SWIGINTERN PiecewiseSplineCubicDiscount *new_PiecewiseSplineCubicDiscount__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::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 >(),SplineCubic const &i=SplineCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseSplineCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseSplineCubicDiscount>(b));
        }
SWIGINTERN PiecewiseSplineCubicDiscount *new_PiecewiseSplineCubicDiscount__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,SplineCubic const &i=SplineCubic()){
            return new PiecewiseSplineCubicDiscount(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseSplineCubicDiscount>(b));
        }
SWIGINTERN PiecewiseSplineCubicDiscount *new_PiecewiseSplineCubicDiscount__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,SplineCubic const &i=SplineCubic()){
            return new PiecewiseSplineCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseSplineCubicDiscount>(b));
        }

typedef PiecewiseYieldCurve<ZeroYield, Kruger> PiecewiseKrugerZero;

SWIGINTERN PiecewiseKrugerZero *new_PiecewiseKrugerZero__SWIG_0(Date const &referenceDate,std::vector< ext::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 >(),Kruger const &i=Kruger(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseKrugerZero(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseKrugerZero>(b));
        }
SWIGINTERN PiecewiseKrugerZero *new_PiecewiseKrugerZero__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::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 >(),Kruger const &i=Kruger(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseKrugerZero(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseKrugerZero>(b));
        }
SWIGINTERN PiecewiseKrugerZero *new_PiecewiseKrugerZero__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,Kruger const &i=Kruger()){
            return new PiecewiseKrugerZero(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseKrugerZero>(b));
        }
SWIGINTERN PiecewiseKrugerZero *new_PiecewiseKrugerZero__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,Kruger const &i=Kruger()){
            return new PiecewiseKrugerZero(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseKrugerZero>(b));
        }

typedef PiecewiseYieldCurve<Discount, KrugerLog> PiecewiseKrugerLogDiscount;

SWIGINTERN PiecewiseKrugerLogDiscount *new_PiecewiseKrugerLogDiscount__SWIG_0(Date const &referenceDate,std::vector< ext::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 >(),KrugerLog const &i=KrugerLog(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseKrugerLogDiscount(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseKrugerLogDiscount>(b));
        }
SWIGINTERN PiecewiseKrugerLogDiscount *new_PiecewiseKrugerLogDiscount__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::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 >(),KrugerLog const &i=KrugerLog(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseKrugerLogDiscount(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseKrugerLogDiscount>(b));
        }
SWIGINTERN PiecewiseKrugerLogDiscount *new_PiecewiseKrugerLogDiscount__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,KrugerLog const &i=KrugerLog()){
            return new PiecewiseKrugerLogDiscount(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseKrugerLogDiscount>(b));
        }
SWIGINTERN PiecewiseKrugerLogDiscount *new_PiecewiseKrugerLogDiscount__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,KrugerLog const &i=KrugerLog()){
            return new PiecewiseKrugerLogDiscount(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseKrugerLogDiscount>(b));
        }

typedef PiecewiseYieldCurve<ForwardRate, ConvexMonotone> PiecewiseConvexMonotoneForward;

SWIGINTERN PiecewiseConvexMonotoneForward *new_PiecewiseConvexMonotoneForward__SWIG_0(Date const &referenceDate,std::vector< ext::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 >(),ConvexMonotone const &i=ConvexMonotone(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseConvexMonotoneForward(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseConvexMonotoneForward>(b));
        }
SWIGINTERN PiecewiseConvexMonotoneForward *new_PiecewiseConvexMonotoneForward__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::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 >(),ConvexMonotone const &i=ConvexMonotone(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseConvexMonotoneForward(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseConvexMonotoneForward>(b));
        }
SWIGINTERN PiecewiseConvexMonotoneForward *new_PiecewiseConvexMonotoneForward__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,ConvexMonotone const &i=ConvexMonotone()){
            return new PiecewiseConvexMonotoneForward(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseConvexMonotoneForward>(b));
        }
SWIGINTERN PiecewiseConvexMonotoneForward *new_PiecewiseConvexMonotoneForward__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,ConvexMonotone const &i=ConvexMonotone()){
            return new PiecewiseConvexMonotoneForward(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseConvexMonotoneForward>(b));
        }

typedef PiecewiseYieldCurve<ZeroYield, ConvexMonotone> PiecewiseConvexMonotoneZero;

SWIGINTERN PiecewiseConvexMonotoneZero *new_PiecewiseConvexMonotoneZero__SWIG_0(Date const &referenceDate,std::vector< ext::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 >(),ConvexMonotone const &i=ConvexMonotone(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseConvexMonotoneZero(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseConvexMonotoneZero>(b));
        }
SWIGINTERN PiecewiseConvexMonotoneZero *new_PiecewiseConvexMonotoneZero__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::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 >(),ConvexMonotone const &i=ConvexMonotone(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseConvexMonotoneZero(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseConvexMonotoneZero>(b));
        }
SWIGINTERN PiecewiseConvexMonotoneZero *new_PiecewiseConvexMonotoneZero__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,ConvexMonotone const &i=ConvexMonotone()){
            return new PiecewiseConvexMonotoneZero(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseConvexMonotoneZero>(b));
        }
SWIGINTERN PiecewiseConvexMonotoneZero *new_PiecewiseConvexMonotoneZero__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,ConvexMonotone const &i=ConvexMonotone()){
            return new PiecewiseConvexMonotoneZero(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseConvexMonotoneZero>(b));
        }

typedef PiecewiseYieldCurve<ZeroYield, SplineCubic> PiecewiseNaturalCubicZero;

SWIGINTERN PiecewiseNaturalCubicZero *new_PiecewiseNaturalCubicZero__SWIG_0(Date const &referenceDate,std::vector< ext::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 >(),SplineCubic const &i=SplineCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseNaturalCubicZero(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseNaturalCubicZero>(b));
        }
SWIGINTERN PiecewiseNaturalCubicZero *new_PiecewiseNaturalCubicZero__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::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 >(),SplineCubic const &i=SplineCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseNaturalCubicZero(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseNaturalCubicZero>(b));
        }
SWIGINTERN PiecewiseNaturalCubicZero *new_PiecewiseNaturalCubicZero__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,SplineCubic const &i=SplineCubic()){
            return new PiecewiseNaturalCubicZero(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseNaturalCubicZero>(b));
        }
SWIGINTERN PiecewiseNaturalCubicZero *new_PiecewiseNaturalCubicZero__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,SplineCubic const &i=SplineCubic()){
            return new PiecewiseNaturalCubicZero(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseNaturalCubicZero>(b));
        }

typedef PiecewiseYieldCurve<Discount, SplineLogCubic> PiecewiseNaturalLogCubicDiscount;

SWIGINTERN PiecewiseNaturalLogCubicDiscount *new_PiecewiseNaturalLogCubicDiscount__SWIG_0(Date const &referenceDate,std::vector< ext::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 >(),SplineLogCubic const &i=SplineLogCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseNaturalLogCubicDiscount(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseNaturalLogCubicDiscount>(b));
        }
SWIGINTERN PiecewiseNaturalLogCubicDiscount *new_PiecewiseNaturalLogCubicDiscount__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::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 >(),SplineLogCubic const &i=SplineLogCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseNaturalLogCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseNaturalLogCubicDiscount>(b));
        }
SWIGINTERN PiecewiseNaturalLogCubicDiscount *new_PiecewiseNaturalLogCubicDiscount__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,SplineLogCubic const &i=SplineLogCubic()){
            return new PiecewiseNaturalLogCubicDiscount(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseNaturalLogCubicDiscount>(b));
        }
SWIGINTERN PiecewiseNaturalLogCubicDiscount *new_PiecewiseNaturalLogCubicDiscount__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,SplineLogCubic const &i=SplineLogCubic()){
            return new PiecewiseNaturalLogCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseNaturalLogCubicDiscount>(b));
        }

typedef PiecewiseYieldCurve<Discount, LogMixedLinearCubic> PiecewiseLogMixedLinearCubicDiscount;

SWIGINTERN PiecewiseLogMixedLinearCubicDiscount *new_PiecewiseLogMixedLinearCubicDiscount__SWIG_0(Date const &referenceDate,std::vector< ext::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 >(),LogMixedLinearCubic const &i=LogMixedLinearCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLogMixedLinearCubicDiscount(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseLogMixedLinearCubicDiscount>(b));
        }
SWIGINTERN PiecewiseLogMixedLinearCubicDiscount *new_PiecewiseLogMixedLinearCubicDiscount__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::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 >(),LogMixedLinearCubic const &i=LogMixedLinearCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLogMixedLinearCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseLogMixedLinearCubicDiscount>(b));
        }
SWIGINTERN PiecewiseLogMixedLinearCubicDiscount *new_PiecewiseLogMixedLinearCubicDiscount__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,LogMixedLinearCubic const &i=LogMixedLinearCubic()){
            return new PiecewiseLogMixedLinearCubicDiscount(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseLogMixedLinearCubicDiscount>(b));
        }
SWIGINTERN PiecewiseLogMixedLinearCubicDiscount *new_PiecewiseLogMixedLinearCubicDiscount__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,LogMixedLinearCubic const &i=LogMixedLinearCubic()){
            return new PiecewiseLogMixedLinearCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseLogMixedLinearCubicDiscount>(b));
        }

class AdditionalErrors {
    std::vector<ext::shared_ptr<RateHelper> > additionalHelpers_;
  public:
    AdditionalErrors(const std::vector<ext::shared_ptr<RateHelper> >& additionalHelpers)
    : additionalHelpers_(additionalHelpers) {}
    Array operator()() const {
        Array errors(additionalHelpers_.size() - 2);
        Real a = additionalHelpers_.front()->impliedQuote();
        Real b = additionalHelpers_.back()->impliedQuote();
        for (Size k = 0; k < errors.size(); ++k) {
            errors[k] = (static_cast<Real>(errors.size()-k) * a + static_cast<Real>(1+k) * b) / static_cast<Real>(errors.size()+1)
                - additionalHelpers_.at(1+k)->impliedQuote();
        }
        return errors;
    }
};

class AdditionalDates {
    std::vector<Date> additionalDates_;
  public:
    AdditionalDates(const std::vector<Date>& additionalDates)
    : additionalDates_(additionalDates) {}
    std::vector<Date> operator()() const {
        return additionalDates_;
    }
};

struct _GlobalBootstrap {
    std::vector<ext::shared_ptr<RateHelper> > additionalHelpers;
    std::vector<Date> additionalDates;
    double accuracy;
    _GlobalBootstrap(double accuracy = Null<double>())
    : accuracy(accuracy) {}
   _GlobalBootstrap(const std::vector<ext::shared_ptr<RateHelper> >& additionalHelpers,
                     const std::vector<Date>& additionalDates,
                     double accuracy = Null<double>())
    : additionalHelpers(additionalHelpers), additionalDates(additionalDates), accuracy(accuracy) {}
};


using QuantLib::SimpleZeroYield;
typedef PiecewiseYieldCurve<SimpleZeroYield, Linear, QuantLib::GlobalBootstrap>
    GlobalLinearSimpleZeroCurve;

SWIGINTERN GlobalLinearSimpleZeroCurve *new_GlobalLinearSimpleZeroCurve(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper > > const &instruments,DayCounter const &dayCounter,_GlobalBootstrap const &b){
            if (b.additionalHelpers.empty()) {
                return new GlobalLinearSimpleZeroCurve(
                    referenceDate, instruments, dayCounter, Linear(),
                    GlobalLinearSimpleZeroCurve::bootstrap_type(b.accuracy));
            } else {
                return new GlobalLinearSimpleZeroCurve(
                    referenceDate, instruments, dayCounter, Linear(),
                    GlobalLinearSimpleZeroCurve::bootstrap_type(b.additionalHelpers,
                                                                AdditionalDates(b.additionalDates),
                                                                AdditionalErrors(b.additionalHelpers),
                                                                b.accuracy));
            }
        }

using QuantLib::DefaultProbabilityTermStructure;

SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_DefaultProbabilityTermStructure_Sg__asObservable(Handle< DefaultProbabilityTermStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_DefaultProbabilityTermStructure_Sg__reset(RelinkableHandle< DefaultProbabilityTermStructure > *self){
            self->linkTo(ext::shared_ptr<DefaultProbabilityTermStructure>());
        }

using QuantLib::FlatHazardRate;


using QuantLib::InterpolatedHazardRateCurve;


using QuantLib::InterpolatedDefaultDensityCurve;


using QuantLib::InterpolatedSurvivalProbabilityCurve;


using QuantLib::DefaultProbabilityHelper;
using QuantLib::SpreadCdsHelper;
using QuantLib::UpfrontCdsHelper;

SWIGINTERN std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *new_std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<DefaultProbabilityHelper> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<DefaultProbabilityHelper> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< DefaultProbabilityHelper > std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__getitem(std::vector< ext::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_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__setitem(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,int index,ext::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_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__AddRange(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__GetRange(std::vector< ext::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< ext::shared_ptr<DefaultProbabilityHelper> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Insert(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,int index,ext::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_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__RemoveAt(std::vector< ext::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_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__RemoveRange(std::vector< ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Repeat(ext::shared_ptr< DefaultProbabilityHelper > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<DefaultProbabilityHelper> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Reverse__SWIG_1(std::vector< ext::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_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__SetRange(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,int index,std::vector< ext::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_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Contains(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,ext::shared_ptr< DefaultProbabilityHelper > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,ext::shared_ptr< DefaultProbabilityHelper > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,ext::shared_ptr< DefaultProbabilityHelper > const &value){
        int index = -1;
        std::vector< ext::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_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Remove(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,ext::shared_ptr< DefaultProbabilityHelper > const &value){
        std::vector< ext::shared_ptr<DefaultProbabilityHelper> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }

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


using QuantLib::PiecewiseDefaultCurve;


typedef PiecewiseDefaultCurve<HazardRate, BackwardFlat> PiecewiseFlatHazardRate;

SWIGINTERN PiecewiseFlatHazardRate *new_PiecewiseFlatHazardRate__SWIG_0(Date const &referenceDate,std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const &instruments,DayCounter const &dayCounter,BackwardFlat const &i=BackwardFlat(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseFlatHazardRate(referenceDate, instruments, dayCounter,
                            i, PiecewiseFlatHazardRate::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseFlatHazardRate *new_PiecewiseFlatHazardRate__SWIG_3(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const &instruments,DayCounter const &dayCounter,BackwardFlat const &i=BackwardFlat(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseFlatHazardRate(settlementDays, calendar, instruments, dayCounter,
                            i, PiecewiseFlatHazardRate::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseFlatHazardRate *new_PiecewiseFlatHazardRate__SWIG_6(Date const &referenceDate,std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b){
            return new PiecewiseFlatHazardRate(referenceDate, instruments, dayCounter,
                            BackwardFlat(), PiecewiseFlatHazardRate::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseFlatHazardRate *new_PiecewiseFlatHazardRate__SWIG_7(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b){
            return new PiecewiseFlatHazardRate(settlementDays, calendar, instruments, dayCounter,
                            BackwardFlat(), PiecewiseFlatHazardRate::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }

using QuantLib::RiskyBondEngine;


using QuantLib::Protection;


using QuantLib::CreditDefaultSwap;
using QuantLib::MidPointCdsEngine;
using QuantLib::IntegralCdsEngine;
using QuantLib::IsdaCdsEngine;
using QuantLib::Claim;
using QuantLib::FaceValueClaim;
using QuantLib::FaceValueAccrualClaim;
using QuantLib::CdsOption;
using QuantLib::BlackCdsOptionEngine;

SWIGINTERN doubleOrNull CreditDefaultSwap_upfront(CreditDefaultSwap const *self){
            ext::optional<Rate> result =
                self->upfront();
            if (result)
                return *result;
            else
                return Null<double>();
        }

using QuantLib::InterpolatedDiscountCurve;


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::Settings::instance().conversionType() = type;
        }
SWIGINTERN void Money_setBaseCurrency(Currency const &c){
            Money::Settings::instance().baseCurrency() = c;
        }

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


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;
        }
SWIGINTERN void Settings_setEnforcesTodaysHistoricFixings(Settings *self,bool b){
            self->enforcesTodaysHistoricFixings() = b;
        }
SWIGINTERN bool Settings_getEnforcesTodaysHistoricFixings(Settings *self){
            return self->enforcesTodaysHistoricFixings();
        }

using QuantLib::Fdm1dMesher;
using QuantLib::FdmBlackScholesMesher;
using QuantLib::Concentrating1dMesher;
using QuantLib::ExponentialJump1dMesher;
using QuantLib::FdmQuantoHelper;
using QuantLib::FdmCEV1dMesher;
using QuantLib::FdmHestonVarianceMesher;
using QuantLib::FdmHestonLocalVolatilityVarianceMesher;
using QuantLib::Uniform1dMesher;
using QuantLib::FdmSimpleProcess1dMesher;
using QuantLib::Predefined1dMesher;
using QuantLib::Glued1dMesher;

SWIGINTERN std::vector< ext::shared_ptr< Fdm1dMesher > > *new_std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<Fdm1dMesher> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<Fdm1dMesher> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< Fdm1dMesher > std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__getitem(std::vector< ext::shared_ptr< Fdm1dMesher > > *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_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__setitem(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,int index,ext::shared_ptr< Fdm1dMesher > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__AddRange(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,std::vector< ext::shared_ptr< Fdm1dMesher > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< Fdm1dMesher > > *std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__GetRange(std::vector< ext::shared_ptr< Fdm1dMesher > > *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< ext::shared_ptr<Fdm1dMesher> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__Insert(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,int index,ext::shared_ptr< Fdm1dMesher > 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_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,int index,std::vector< ext::shared_ptr< Fdm1dMesher > > 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_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__RemoveAt(std::vector< ext::shared_ptr< Fdm1dMesher > > *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_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__RemoveRange(std::vector< ext::shared_ptr< Fdm1dMesher > > *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< ext::shared_ptr< Fdm1dMesher > > *std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__Repeat(ext::shared_ptr< Fdm1dMesher > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<Fdm1dMesher> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< Fdm1dMesher > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__Reverse__SWIG_1(std::vector< ext::shared_ptr< Fdm1dMesher > > *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_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__SetRange(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,int index,std::vector< ext::shared_ptr< Fdm1dMesher > > 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_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__Contains(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,ext::shared_ptr< Fdm1dMesher > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,ext::shared_ptr< Fdm1dMesher > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<Fdm1dMesher> >::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_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,ext::shared_ptr< Fdm1dMesher > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<Fdm1dMesher> >::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_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__Remove(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,ext::shared_ptr< Fdm1dMesher > const &value){
        std::vector< ext::shared_ptr<Fdm1dMesher> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN double ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__first(ext::tuple< Real,Real,bool > const *self){
        return ext::get<0>(*self);
      }
SWIGINTERN double ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__second(ext::tuple< Real,Real,bool > const *self){
        return ext::get<1>(*self);
      }
SWIGINTERN bool ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__third(ext::tuple< Real,Real,bool > const *self){
        return ext::get<2>(*self);
      }
SWIGINTERN std::vector< ext::tuple< Real,Real,bool > > *new_std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::tuple< Real,Real,bool > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::tuple< Real,Real,bool > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::tuple< Real,Real,bool > std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__getitemcopy(std::vector< ext::tuple< Real,Real,bool > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::tuple< double,double,bool > >::value_type const &std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__getitem(std::vector< ext::tuple< Real,Real,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_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__setitem(std::vector< ext::tuple< Real,Real,bool > > *self,int index,ext::tuple< Real,Real,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_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__AddRange(std::vector< ext::tuple< Real,Real,bool > > *self,std::vector< ext::tuple< Real,Real,bool > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::tuple< Real,Real,bool > > *std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__GetRange(std::vector< ext::tuple< Real,Real,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< ext::tuple< Real,Real,bool > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__Insert(std::vector< ext::tuple< Real,Real,bool > > *self,int index,ext::tuple< Real,Real,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_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__InsertRange(std::vector< ext::tuple< Real,Real,bool > > *self,int index,std::vector< ext::tuple< Real,Real,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_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__RemoveAt(std::vector< ext::tuple< Real,Real,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_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__RemoveRange(std::vector< ext::tuple< Real,Real,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< ext::tuple< Real,Real,bool > > *std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__Repeat(ext::tuple< Real,Real,bool > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::tuple< Real,Real,bool > >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__Reverse__SWIG_0(std::vector< ext::tuple< Real,Real,bool > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__Reverse__SWIG_1(std::vector< ext::tuple< Real,Real,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_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__SetRange(std::vector< ext::tuple< Real,Real,bool > > *self,int index,std::vector< ext::tuple< Real,Real,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);
      }

using QuantLib::FdmLinearOpIterator;
using QuantLib::FdmLinearOpLayout;
using QuantLib::FdmMesher;
using QuantLib::FdmMesherComposite;

SWIGINTERN FdmLinearOpIterator *new_FdmLinearOpIterator__SWIG_0(std::vector< unsigned int > const &dim){
            return new FdmLinearOpIterator(to_vector<Size>(dim));
        }
SWIGINTERN FdmLinearOpIterator *new_FdmLinearOpIterator__SWIG_1(std::vector< unsigned int > const &dim,std::vector< unsigned int > const &coordinates,Size index){
            return new FdmLinearOpIterator(to_vector<Size>(dim),
                                           to_vector<Size>(coordinates),
                                           index);
        }
SWIGINTERN std::vector< unsigned int > FdmLinearOpIterator_coordinates(FdmLinearOpIterator *self){
            return to_vector<unsigned int>(self->coordinates());
        }
SWIGINTERN void FdmLinearOpIterator_increment(FdmLinearOpIterator *self){
            ++(*self);
        }
SWIGINTERN bool FdmLinearOpIterator_notEqual(FdmLinearOpIterator *self,FdmLinearOpIterator const &iterator){
            return self->operator!=(iterator);
        }
SWIGINTERN FdmLinearOpLayout *new_FdmLinearOpLayout(std::vector< unsigned int > const &dim){
            return new FdmLinearOpLayout(to_vector<Size>(dim));
        }
SWIGINTERN std::vector< unsigned int > FdmLinearOpLayout_spacing(FdmLinearOpLayout *self){
            return to_vector<unsigned int>(self->spacing());
        }
SWIGINTERN std::vector< unsigned int > FdmLinearOpLayout_dim(FdmLinearOpLayout const *self){
            return to_vector<unsigned int>(self->dim());
        }
SWIGINTERN Size FdmLinearOpLayout_index(FdmLinearOpLayout const *self,std::vector< unsigned int > const &coordinates){
            return self->index(to_vector<Size>(coordinates));
        }

using QuantLib::FdmLinearOp;
using QuantLib::FdmLinearOpComposite;


class SparseMatrix {
  public:
    std::vector<unsigned int> row_idx, col_idx;
    std::vector<Real> data;    
};

SWIGINTERN ext::shared_ptr< SparseMatrix > FdmLinearOpComposite_to_sparse_matrix(FdmLinearOpComposite const *self){
            
            ext::shared_ptr<SparseMatrix> a = ext::make_shared<SparseMatrix>();
            
            const QuantLib::SparseMatrix m = self->toMatrix(); 
            
            Size entries(0);
            for (auto iter1 = m.begin1(); iter1 != m.end1(); ++iter1)
                entries+=std::distance(iter1.begin(), iter1.end());
        
            a->row_idx.reserve(entries);
            a->col_idx.reserve(entries);
            a->data.reserve(entries);
            
            for (auto iter1 = m.begin1(); iter1 != m.end1(); ++iter1)
                for (auto iter2 = iter1.begin(); iter2 != iter1.end(); ++iter2) {
                    a->row_idx.push_back(iter1.index1());
                    a->col_idx.push_back(iter2.index2());
                    a->data.push_back(*iter2);
                }
    
            return a;
        }

class FdmLinearOpCompositeDelegate {
  public:
    virtual ~FdmLinearOpCompositeDelegate() {}

    virtual Size size() const {
        QL_FAIL("implementation of FdmLinearOpCompositeDelegate.size is missing");        
    }

    virtual void setTime(Time t1, Time t2) {
        QL_FAIL("implementation of FdmLinearOpCompositeDelegate.setTime is missing");    
    }

    virtual Array apply(const Array& r) const {
        QL_FAIL("implementation of FdmLinearOpCompositeDelegate.apply is missing");    
    }

    virtual Array apply_mixed(const Array& r) const {
        QL_FAIL("implementation of FdmLinearOpCompositeDelegate.apply_mixed is missing");    
    }    
    
    virtual Array apply_direction(Size direction, const Array& r) const {
        QL_FAIL("implementation of FdmLinearOpCompositeDelegate.apply_direction is missing");    
    }

    virtual Array solve_splitting(Size direction, const Array& r, Real s) const {
        QL_FAIL("implementation of FdmLinearOpCompositeDelegate.solve_splitting is missing");        
    }    
    
    virtual Array preconditioner(const Array& r, Real dt) const {
        return solve_splitting(0, r, dt);
    }
};

class FdmLinearOpCompositeProxy : public FdmLinearOpComposite {
  public:
    FdmLinearOpCompositeProxy(FdmLinearOpCompositeDelegate* delegate)
    : delegate_(delegate) {}

    Size size() const { return delegate_->size(); }
    void setTime(Time t1, Time t2) { delegate_->setTime(t1, t2); }

    Array apply(const Array& r) const {
        Array retVal = delegate_->apply(r);
        return retVal;
    }
    Array apply_mixed(const Array& r) const {
        Array retVal = delegate_->apply_mixed(r);
        return retVal;
    }        
    Array apply_direction(Size direction, const Array& r) const {
        Array retVal = delegate_->apply_direction(direction, r);
        return retVal;
    }
    Array solve_splitting(Size direction, const Array& r, Real s) const {
        Array retVal = delegate_->solve_splitting(direction, r, s);
        return retVal;
    }
    Array preconditioner(const Array& r, Real s) const {
        Array retVal = delegate_->preconditioner(r, s);
        return retVal;
    }
               
  private:
      FdmLinearOpCompositeDelegate* const delegate_; 
};


using QuantLib::FdmDiscountDirichletBoundary;
using QuantLib::FdmDirichletBoundary;
using QuantLib::BoundaryCondition;
using QuantLib::FdmTimeDepDirichletBoundary;
using QuantLib::FdmBlackScholesOp;
using QuantLib::Fdm2dBlackScholesOp;
using QuantLib::FdmBatesOp;
using QuantLib::FdmCEVOp;
using QuantLib::FdmG2Op;
using QuantLib::FdmHestonHullWhiteOp;
using QuantLib::FdmHestonOp;
using QuantLib::FdmHullWhiteOp;
using QuantLib::FdmLocalVolFwdOp;
using QuantLib::FdmOrnsteinUhlenbeckOp;
using QuantLib::FdmSabrOp;
using QuantLib::FdmZabrOp;
using QuantLib::FdmDupire1dOp;
using QuantLib::FdmBlackScholesFwdOp;
using QuantLib::FdmHestonFwdOp;
using QuantLib::FdmSquareRootFwdOp;

typedef BoundaryCondition<FdmLinearOp> FdmBoundaryCondition;
typedef std::vector<ext::shared_ptr<FdmBoundaryCondition> > FdmBoundaryConditionSet;

SWIGINTERN std::vector< ext::shared_ptr< FdmBoundaryCondition > > *new_std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<FdmBoundaryCondition> >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<FdmBoundaryCondition> >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< FdmBoundaryCondition > std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__getitem(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *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_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__setitem(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,int index,ext::shared_ptr< FdmBoundaryCondition > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__AddRange(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,std::vector< ext::shared_ptr< FdmBoundaryCondition > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< FdmBoundaryCondition > > *std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__GetRange(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *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< ext::shared_ptr<FdmBoundaryCondition> >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__Insert(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,int index,ext::shared_ptr< FdmBoundaryCondition > 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_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__InsertRange(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,int index,std::vector< ext::shared_ptr< FdmBoundaryCondition > > 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_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__RemoveAt(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *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_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__RemoveRange(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *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< ext::shared_ptr< FdmBoundaryCondition > > *std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__Repeat(ext::shared_ptr< FdmBoundaryCondition > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<FdmBoundaryCondition> >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__Reverse__SWIG_1(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *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_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__SetRange(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,int index,std::vector< ext::shared_ptr< FdmBoundaryCondition > > 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_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__Contains(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,ext::shared_ptr< FdmBoundaryCondition > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__IndexOf(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,ext::shared_ptr< FdmBoundaryCondition > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<FdmBoundaryCondition> >::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_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,ext::shared_ptr< FdmBoundaryCondition > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<FdmBoundaryCondition> >::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_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__Remove(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,ext::shared_ptr< FdmBoundaryCondition > const &value){
        std::vector< ext::shared_ptr<FdmBoundaryCondition> >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN FdmTimeDepDirichletBoundary *new_FdmTimeDepDirichletBoundary(ext::shared_ptr< FdmMesher > const &mesher,UnaryFunctionDelegate *function,Size direction,FdmTimeDepDirichletBoundary::Side side){

            const ext::function<Real(Real)> f = UnaryFunction(function);
            return new FdmTimeDepDirichletBoundary(
                mesher, f, direction, side);        
         }

using QuantLib::TripleBandLinearOp;
using QuantLib::FirstDerivativeOp;
using QuantLib::SecondDerivativeOp;
using QuantLib::NinePointLinearOp;
using QuantLib::SecondOrderMixedDerivativeOp;
using QuantLib::NthOrderDerivativeOp;


using QuantLib::CraigSneydScheme;
using QuantLib::CrankNicolsonScheme;
using QuantLib::ImplicitEulerScheme;
using QuantLib::DouglasScheme;
using QuantLib::ExplicitEulerScheme;
using QuantLib::HundsdorferScheme;
using QuantLib::MethodOfLinesScheme;
using QuantLib::ModifiedCraigSneydScheme;


using QuantLib::StepCondition;
using QuantLib::FdmSnapshotCondition;
using QuantLib::FdmAmericanStepCondition;
using QuantLib::FdmArithmeticAverageCondition;
using QuantLib::FdmSimpleSwingCondition;
using QuantLib::FdmBermudanStepCondition;
using QuantLib::FdmSimpleStorageCondition;
using QuantLib::FdmSimpleSwingCondition;
using QuantLib::FdmDividendHandler;
using QuantLib::FdmInnerValueCalculator;
using QuantLib::FdmCellAveragingInnerValue;
using QuantLib::FdmLogInnerValue;
using QuantLib::FdmLogBasketInnerValue;
using QuantLib::FdmZeroInnerValue;
using QuantLib::FdmAffineModelSwapInnerValue;
using QuantLib::FdmStepConditionComposite;


class FdmStepConditionDelegate {
  public:
    virtual ~FdmStepConditionDelegate() {}

    virtual void applyTo(Array& a, Time t) const {
        QL_FAIL("implementation of FdmStepCondition.applyTo is missing");        
    }
};

class FdmStepConditionProxy : public StepCondition<Array> {
  public:
    FdmStepConditionProxy(FdmStepConditionDelegate* delegate)
    : delegate_(delegate) {}

    void applyTo(Array& a, Time t) const {
        delegate_->applyTo(a, t);
    }
    
  private:  
      FdmStepConditionDelegate* const delegate_; 
};


class FdmInnerValueCalculatorDelegate {
  public:
    virtual ~FdmInnerValueCalculatorDelegate() {}
      
    virtual Real innerValue(const FdmLinearOpIterator& iter, Time t) {
        QL_FAIL("implementation of FdmInnerValueCalculatorDelegate.innerValue is missing");        
    }
    virtual Real avgInnerValue(const FdmLinearOpIterator& iter, Time t) {
        QL_FAIL("implementation of FdmInnerValueCalculatorDelegate.avgInnerValue is missing");            
    }
};

class FdmInnerValueCalculatorProxy : public FdmInnerValueCalculator {
  public:
    FdmInnerValueCalculatorProxy(FdmInnerValueCalculatorDelegate* delegate)
    : delegate_(delegate) {}

    Real innerValue(const FdmLinearOpIterator& iter, Time t) {
        return delegate_->innerValue(iter, t);
    }
    Real avgInnerValue(const FdmLinearOpIterator& iter, Time t) {
        return delegate_->avgInnerValue(iter, t);
    }
    
  private:  
      FdmInnerValueCalculatorDelegate* const delegate_; 
};

SWIGINTERN FdmCellAveragingInnerValue *new_FdmCellAveragingInnerValue__SWIG_0(ext::shared_ptr< Payoff > const &payoff,ext::shared_ptr< FdmMesher > const &mesher,Size direction,UnaryFunctionDelegate *gridMapping){
            
                UnaryFunction f(gridMapping);
                return new FdmCellAveragingInnerValue(payoff, mesher, direction, f);            
        }
SWIGINTERN FdmCellAveragingInnerValue *new_FdmCellAveragingInnerValue__SWIG_1(ext::shared_ptr< Payoff > const &payoff,ext::shared_ptr< FdmMesher > const &mesher,Size direction){
                return new FdmCellAveragingInnerValue(payoff, mesher, direction);            
        }
SWIGINTERN std::map< double,Date >::mapped_type const &std_map_Sl_Time_Sc_Date_Sg__getitem(std::map< Time,Date > *self,std::map< double,Date >::key_type const &key){
        std::map< double, Date, std::less< double > >::iterator iter = self->find(key);
        if (iter != self->end())
          return iter->second;
        else
          throw std::out_of_range("key not found");
      }
SWIGINTERN void std_map_Sl_Time_Sc_Date_Sg__setitem(std::map< Time,Date > *self,std::map< double,Date >::key_type const &key,std::map< double,Date >::mapped_type const &x){
        (*self)[key] = x;
      }
SWIGINTERN bool std_map_Sl_Time_Sc_Date_Sg__ContainsKey(std::map< Time,Date > *self,std::map< double,Date >::key_type const &key){
        std::map< double, Date, std::less< double > >::iterator iter = self->find(key);
        return iter != self->end();
      }
SWIGINTERN void std_map_Sl_Time_Sc_Date_Sg__Add(std::map< Time,Date > *self,std::map< double,Date >::key_type const &key,std::map< double,Date >::mapped_type const &value){
        std::map< double, Date, std::less< double > >::iterator iter = self->find(key);
        if (iter != self->end())
          throw std::out_of_range("key already exists");
        self->insert(std::pair< double, Date >(key, value));
      }
SWIGINTERN bool std_map_Sl_Time_Sc_Date_Sg__Remove(std::map< Time,Date > *self,std::map< double,Date >::key_type const &key){
        std::map< double, Date, std::less< double > >::iterator iter = self->find(key);
        if (iter != self->end()) {
          self->erase(iter);
          return true;
        }
        return false;
      }
SWIGINTERN std::map< double,Date,std::less< double > >::iterator *std_map_Sl_Time_Sc_Date_Sg__create_iterator_begin(std::map< Time,Date > *self){
        return new std::map< double, Date, std::less< double > >::iterator(self->begin());
      }
SWIGINTERN std::map< double,Date >::key_type const &std_map_Sl_Time_Sc_Date_Sg__get_next_key(std::map< Time,Date > *self,std::map< double,Date,std::less< double > >::iterator *swigiterator){
        std::map< double, Date, std::less< double > >::iterator iter = *swigiterator;
        (*swigiterator)++;
        return (*iter).first;
      }
SWIGINTERN void std_map_Sl_Time_Sc_Date_Sg__destroy_iterator(std::map< Time,Date > *self,std::map< double,Date,std::less< double > >::iterator *swigiterator){
        delete swigiterator;
      }
SWIGINTERN std::vector< ext::shared_ptr< StepCondition< Array > > > *new_std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg___SWIG_2(int capacity){
        std::vector< ext::shared_ptr<StepCondition<Array> > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< ext::shared_ptr<StepCondition<Array> > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN ext::shared_ptr< StepCondition< Array > > std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__getitemcopy(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__getitem(std::vector< ext::shared_ptr< StepCondition< Array > > > *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_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__setitem(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,int index,ext::shared_ptr< StepCondition< Array > > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__AddRange(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,std::vector< ext::shared_ptr< StepCondition< Array > > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< ext::shared_ptr< StepCondition< Array > > > *std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__GetRange(std::vector< ext::shared_ptr< StepCondition< Array > > > *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< ext::shared_ptr<StepCondition<Array> > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__Insert(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,int index,ext::shared_ptr< StepCondition< Array > > 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_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__InsertRange(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,int index,std::vector< ext::shared_ptr< StepCondition< Array > > > 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_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__RemoveAt(std::vector< ext::shared_ptr< StepCondition< Array > > > *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_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__RemoveRange(std::vector< ext::shared_ptr< StepCondition< Array > > > *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< ext::shared_ptr< StepCondition< Array > > > *std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__Repeat(ext::shared_ptr< StepCondition< Array > > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< ext::shared_ptr<StepCondition<Array> > >(count, value);
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__Reverse__SWIG_0(std::vector< ext::shared_ptr< StepCondition< Array > > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__Reverse__SWIG_1(std::vector< ext::shared_ptr< StepCondition< Array > > > *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_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__SetRange(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,int index,std::vector< ext::shared_ptr< StepCondition< Array > > > 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_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__Contains(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,ext::shared_ptr< StepCondition< Array > > const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__IndexOf(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,ext::shared_ptr< StepCondition< Array > > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<StepCondition<Array> > >::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_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__LastIndexOf(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,ext::shared_ptr< StepCondition< Array > > const &value){
        int index = -1;
        std::vector< ext::shared_ptr<StepCondition<Array> > >::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_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__Remove(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,ext::shared_ptr< StepCondition< Array > > const &value){
        std::vector< ext::shared_ptr<StepCondition<Array> > >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN FdmStepConditionComposite *new_FdmStepConditionComposite(std::vector< Time > const &stoppingTimes,std::vector< ext::shared_ptr< StepCondition< Array > > > const &conditions){
            return new FdmStepConditionComposite(
                std::list<std::vector<Time> >(1, stoppingTimes), 
                std::list<ext::shared_ptr<StepCondition<Array> > >(
                    conditions.begin(), conditions.end()));
        }

using QuantLib::FdmSolverDesc;
using QuantLib::Fdm1DimSolver;
using QuantLib::FdmBackwardSolver;
using QuantLib::Fdm2dBlackScholesSolver;
using QuantLib::Fdm2DimSolver;
using QuantLib::Fdm3DimSolver;
using QuantLib::FdmG2Solver;
using QuantLib::FdmHestonHullWhiteSolver;
using QuantLib::FdmHestonSolver;
using QuantLib::FdmHullWhiteSolver;
using QuantLib::FdmNdimSolver;

SWIGINTERN FdmSolverDesc *new_FdmSolverDesc(ext::shared_ptr< FdmMesher > const &mesher,FdmBoundaryConditionSet const &bcSet,ext::shared_ptr< FdmStepConditionComposite > const &condition,ext::shared_ptr< FdmInnerValueCalculator > const &calculator,Time maturity,Size timeSteps,Size dampingSteps){
            
            const FdmSolverDesc desc = { 
                mesher, bcSet, condition, calculator, 
                maturity, timeSteps, dampingSteps };
            
            return new FdmSolverDesc(desc);            
        }
SWIGINTERN ext::shared_ptr< FdmMesher > FdmSolverDesc_getMesher(FdmSolverDesc const *self){ return self->mesher; }
SWIGINTERN FdmBoundaryConditionSet const &FdmSolverDesc_getBcSet(FdmSolverDesc const *self){ return self->bcSet; }
SWIGINTERN ext::shared_ptr< FdmStepConditionComposite > FdmSolverDesc_getStepConditions(FdmSolverDesc const *self){ return self->condition; }
SWIGINTERN ext::shared_ptr< FdmInnerValueCalculator > FdmSolverDesc_getCalculator(FdmSolverDesc const *self){ return self->calculator; }
SWIGINTERN Time FdmSolverDesc_getMaturity(FdmSolverDesc const *self){ return self->maturity; }
SWIGINTERN Size FdmSolverDesc_getTimeSteps(FdmSolverDesc const *self){ return self->timeSteps; }
SWIGINTERN Size FdmSolverDesc_getDampingSteps(FdmSolverDesc const *self){ return self->dampingSteps; }
SWIGINTERN Fdm2dBlackScholesSolver *new_Fdm2dBlackScholesSolver__SWIG_0(ext::shared_ptr< GeneralizedBlackScholesProcess > const &p1,ext::shared_ptr< GeneralizedBlackScholesProcess > const &p2,Real const correlation,FdmSolverDesc const &solverDesc,FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Hundsdorfer(),bool localVol=false,Real illegalLocalVolOverwrite=-Null< Real >()){
                return new Fdm2dBlackScholesSolver(
                    Handle<GeneralizedBlackScholesProcess>(p1), 
                    Handle<GeneralizedBlackScholesProcess>(p2), 
                    correlation, solverDesc, schemeDesc, 
                    localVol, illegalLocalVolOverwrite); 
        }
SWIGINTERN FdmG2Solver *new_FdmG2Solver__SWIG_0(ext::shared_ptr< G2 > const &model,FdmSolverDesc const &solverDesc,FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Hundsdorfer()){
                return new FdmG2Solver(Handle<G2>(model), solverDesc, schemeDesc);            
        }
SWIGINTERN FdmHestonHullWhiteSolver *new_FdmHestonHullWhiteSolver__SWIG_0(ext::shared_ptr< HestonProcess > const &hestonProcess,ext::shared_ptr< HullWhiteProcess > const &hwProcess,Rate corrEquityShortRate,FdmSolverDesc const &solverDesc,FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Hundsdorfer()){
                return new FdmHestonHullWhiteSolver(
                    Handle<HestonProcess>(hestonProcess),
                    Handle<HullWhiteProcess>(hwProcess),
                    corrEquityShortRate, solverDesc, schemeDesc);                    
        }
SWIGINTERN FdmHestonSolver *new_FdmHestonSolver__SWIG_0(ext::shared_ptr< HestonProcess > const &process,FdmSolverDesc const &solverDesc,FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Hundsdorfer(),ext::shared_ptr< FdmQuantoHelper > const &quantoHelper=ext::shared_ptr< FdmQuantoHelper >(),ext::shared_ptr< LocalVolTermStructure > const &leverageFct=ext::shared_ptr< LocalVolTermStructure >()){

                return new FdmHestonSolver(
                    Handle<HestonProcess>(process),
                    solverDesc, schemeDesc, 
                    Handle<FdmQuantoHelper>(quantoHelper), 
                    leverageFct);
        }
SWIGINTERN FdmHullWhiteSolver *new_FdmHullWhiteSolver__SWIG_0(ext::shared_ptr< HullWhite > const &model,FdmSolverDesc const &solverDesc,FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Hundsdorfer()){
                return new FdmHullWhiteSolver(
                    Handle<HullWhite>(model), solverDesc, schemeDesc);
        }

using QuantLib::FdmIndicesOnBoundary;
using QuantLib::RiskNeutralDensityCalculator;
using QuantLib::BSMRNDCalculator;
using QuantLib::CEVRNDCalculator;
using QuantLib::GBSMRNDCalculator;
using QuantLib::HestonRNDCalculator;
using QuantLib::LocalVolRNDCalculator;
using QuantLib::SquareRootProcessRNDCalculator;

SWIGINTERN std::vector< unsigned int > FdmIndicesOnBoundary_getIndices(FdmIndicesOnBoundary const *self){
            return to_vector<unsigned int>(self->getIndices());
        }
SWIGINTERN std::vector< unsigned int > LocalVolRNDCalculator_rescaleTimeSteps(LocalVolRNDCalculator const *self){
            return to_vector<unsigned int>(self->rescaleTimeSteps());
        }

using QuantLib::FittedBondDiscountCurve;

typedef QuantLib::FittedBondDiscountCurve::FittingMethod FittingMethod;

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


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


using QuantLib::InterpolatedForwardCurve;


using QuantLib::Position;
using QuantLib::ForwardRateAgreement;


using QuantLib::Gaussian1dModel;


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


using QuantLib::Gaussian1dCapFloorEngine;
using QuantLib::Gaussian1dSwaptionEngine;
using QuantLib::Gaussian1dJamshidianSwaptionEngine;
using QuantLib::Gaussian1dNonstandardSwaptionEngine;
using QuantLib::Gaussian1dFloatFloatSwaptionEngine;


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::TanhSinhIntegral;
using QuantLib::ExpSinhIntegral;

SWIGINTERN Real SegmentIntegral_calculate(SegmentIntegral *self,UnaryFunctionDelegate *f,Real a,Real b){
            return (*self)(UnaryFunction(f), a, b);		
        }
SWIGINTERN Real TrapezoidIntegral_Sl_Default_Sg__calculate(TrapezoidIntegral< Default > *self,UnaryFunctionDelegate *f,Real a,Real b){
            return (*self)(UnaryFunction(f), a, b);		
        }
SWIGINTERN Real TrapezoidIntegral_Sl_MidPoint_Sg__calculate(TrapezoidIntegral< MidPoint > *self,UnaryFunctionDelegate *f,Real a,Real b){
            return (*self)(UnaryFunction(f), a, b);		
        }
SWIGINTERN Real SimpsonIntegral_calculate(SimpsonIntegral *self,UnaryFunctionDelegate *f,Real a,Real b){
            return (*self)(UnaryFunction(f), a, b);		
        }
SWIGINTERN Real GaussKronrodAdaptive_calculate(GaussKronrodAdaptive *self,UnaryFunctionDelegate *f,Real a,Real b){
            return (*self)(UnaryFunction(f), a, b);		
        }
SWIGINTERN Real GaussKronrodNonAdaptive_calculate(GaussKronrodNonAdaptive *self,UnaryFunctionDelegate *f,Real a,Real b){
            return (*self)(UnaryFunction(f), a, b);		
        }
SWIGINTERN Real GaussLobattoIntegral_calculate(GaussLobattoIntegral *self,UnaryFunctionDelegate *f,Real a,Real b){
            return (*self)(UnaryFunction(f), a, b);		
        }

using QuantLib::GaussianQuadrature;

SWIGINTERN Array GaussianQuadrature_weights(GaussianQuadrature *self){ 
        return self->weights(); 
      }
SWIGINTERN Array GaussianQuadrature_x(GaussianQuadrature *self){ 
        return self->x(); 
      }
SWIGINTERN Real GaussianQuadrature_calculate(GaussianQuadrature *self,UnaryFunctionDelegate *f){
          return (*self)(UnaryFunction(f));
      }
SWIGINTERN Real TanhSinhIntegral_calculate(TanhSinhIntegral *self,UnaryFunctionDelegate *f,Real a,Real b){
            return (*self)(UnaryFunction(f), a, b);		
        }
SWIGINTERN Real ExpSinhIntegral_integrate(ExpSinhIntegral *self,UnaryFunctionDelegate *f){
            return self->integrate(UnaryFunction(f));		
        }
SWIGINTERN Real ExpSinhIntegral_calculate(ExpSinhIntegral *self,UnaryFunctionDelegate *f,Real a,Real b){
            return (*self)(UnaryFunction(f), a, b);		
        }

using QuantLib::LocalConstantVol;


using QuantLib::LocalVolSurface;


using QuantLib::NoExceptLocalVolSurface;


using QuantLib::FixedLocalVolSurface;
using QuantLib::GridModelLocalVolSurface;

SWIGINTERN FixedLocalVolSurface *new_FixedLocalVolSurface__SWIG_0(Date const &referenceDate,std::vector< Date > const &dates,std::vector< Real > const &strikes,Matrix localVolMatrix,DayCounter const &dayCounter,FixedLocalVolSurface::Extrapolation lowerExtrapolation=FixedLocalVolSurface::ConstantExtrapolation,FixedLocalVolSurface::Extrapolation upperExtrapolation=FixedLocalVolSurface::ConstantExtrapolation){
            ext::shared_ptr<Matrix> pMatrix = ext::make_shared<Matrix>(localVolMatrix);
            return new FixedLocalVolSurface(referenceDate, dates, strikes, pMatrix,
                                            dayCounter, lowerExtrapolation, upperExtrapolation);
        }
SWIGINTERN FixedLocalVolSurface *new_FixedLocalVolSurface__SWIG_3(Date const &referenceDate,std::vector< Time > const &times,std::vector< Real > const &strikes,Matrix localVolMatrix,DayCounter const &dayCounter,FixedLocalVolSurface::Extrapolation lowerExtrapolation=FixedLocalVolSurface::ConstantExtrapolation,FixedLocalVolSurface::Extrapolation upperExtrapolation=FixedLocalVolSurface::ConstantExtrapolation){
            ext::shared_ptr<Matrix> pMatrix = ext::make_shared<Matrix>(localVolMatrix);
            return new FixedLocalVolSurface(referenceDate, times, strikes, pMatrix,
                                            dayCounter, lowerExtrapolation, upperExtrapolation);
        }
SWIGINTERN FixedLocalVolSurface *new_FixedLocalVolSurface__SWIG_6(Date const &referenceDate,std::vector< Time > const &times,std::vector< std::vector< Real > > const &strikes,Matrix localVolMatrix,DayCounter const &dayCounter,FixedLocalVolSurface::Extrapolation lowerExtrapolation=FixedLocalVolSurface::ConstantExtrapolation,FixedLocalVolSurface::Extrapolation upperExtrapolation=FixedLocalVolSurface::ConstantExtrapolation){
            std::vector<ext::shared_ptr<std::vector<Real> > > pStrikes(strikes.size());
            for (Size i=0; i<strikes.size(); ++i)
                pStrikes[i] = ext::make_shared<std::vector<Real>>(strikes[i]);
            ext::shared_ptr<Matrix> pMatrix = ext::make_shared<Matrix>(localVolMatrix);
            return new FixedLocalVolSurface(referenceDate, times, pStrikes, pMatrix,
                                            dayCounter, lowerExtrapolation, upperExtrapolation);
        }
SWIGINTERN void FixedLocalVolSurface_setInterpolation__SWIG_0(FixedLocalVolSurface *self,std::string const &interpolator=""){
            const std::string s = boost::to_lower_copy(interpolator);
            if (s == "" || s == "linear") {
                self->setInterpolation<QuantLib::Linear>();
            } else if (s == "cubic") {
                self->setInterpolation<QuantLib::Cubic>();
            } else {
                QL_FAIL("Unknown interpolator: " << interpolator);
            }
        }
SWIGINTERN GridModelLocalVolSurface *new_GridModelLocalVolSurface__SWIG_0(Date const &referenceDate,std::vector< Date > const &dates,std::vector< std::vector< Real > > const &strikes,DayCounter const &dayCounter,GridModelLocalVolSurface::Extrapolation lowerExtrapolation=FixedLocalVolSurface::ConstantExtrapolation,GridModelLocalVolSurface::Extrapolation upperExtrapolation=FixedLocalVolSurface::ConstantExtrapolation){
            std::vector<ext::shared_ptr<std::vector<Real> > > pStrikes(strikes.size());
            for (Size i=0; i<strikes.size(); ++i)
                pStrikes[i] = ext::make_shared<std::vector<Real>>(strikes[i]);
            return new GridModelLocalVolSurface(referenceDate, dates, pStrikes,
                                                dayCounter, lowerExtrapolation, upperExtrapolation);
        }

using QuantLib::Sample;

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

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;
using QuantLib::Burley2020SobolRsg;
using QuantLib::Burley2020SobolBrownianBridgeRsg;

typedef QuantLib::LowDiscrepancy::ursg_type
    UniformLowDiscrepancySequenceGenerator;

using QuantLib::InverseCumulativeRsg;

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

SWIGINTERN double const &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 const &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 > const &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){
          return to_vector<unsigned int>(self->nextInt32Sequence());
      }
SWIGINTERN std::vector< unsigned int > Burley2020SobolRsg_nextInt32Sequence(Burley2020SobolRsg *self){
          return to_vector<unsigned int>(self->nextInt32Sequence());
      }

using QuantLib::BrownianGenerator;
using QuantLib::MTBrownianGenerator;
using QuantLib::SobolBrownianGenerator;
using QuantLib::BrownianGeneratorFactory;
using QuantLib::MTBrownianGeneratorFactory;
using QuantLib::SobolBrownianGeneratorFactory;


using QuantLib::EvolutionDescription;

SWIGINTERN EvolutionDescription *new_EvolutionDescription__SWIG_0(std::vector< Time > const &rateTimes,std::vector< Time > const &evolutionTimes={},std::vector< std::pair< unsigned int,unsigned int > > const &relevanceRates={}){
            return new EvolutionDescription(rateTimes, evolutionTimes,
                                            to_vector<std::pair<Size, Size>>(relevanceRates));
        }
SWIGINTERN std::vector< unsigned int > EvolutionDescription_firstAliveRate(EvolutionDescription const *self){
            return to_vector<unsigned int>(self->firstAliveRate());
        }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int > > EvolutionDescription_relevanceRates(EvolutionDescription const *self){
            return to_vector<std::pair<unsigned int, unsigned int>>(self->relevanceRates());
        }


    void _checkCompatibility(const EvolutionDescription& evolution,
                             const std::vector<unsigned int>& numeraires) {
        QuantLib::checkCompatibility(evolution, to_vector<Size>(numeraires));
    }

    bool _isInTerminalMeasure(const EvolutionDescription& evolution,
                              const std::vector<unsigned int>& numeraires) {
        return QuantLib::isInTerminalMeasure(evolution, to_vector<Size>(numeraires));
    }

    bool _isInMoneyMarketPlusMeasure(const EvolutionDescription& evolution,
                                     const std::vector<unsigned int>& numeraires,
                                     Size offset = 1) {
        return QuantLib::isInMoneyMarketPlusMeasure(evolution, to_vector<Size>(numeraires), offset);
    }

    bool _isInMoneyMarketMeasure(const EvolutionDescription& evolution,
                                 const std::vector<unsigned int>& numeraires) {
        return QuantLib::isInMoneyMarketMeasure(evolution, to_vector<Size>(numeraires));
    }

    std::vector<unsigned int> _terminalMeasure(const EvolutionDescription& evolution) {
        return to_vector<unsigned int>(QuantLib::terminalMeasure(evolution));
    }

    std::vector<unsigned int> _moneyMarketPlusMeasure(const EvolutionDescription& evolution,
                                                      Size offset = 1) {
        return to_vector<unsigned int>(QuantLib::moneyMarketPlusMeasure(evolution, offset));
    }

    std::vector<unsigned int> _moneyMarketMeasure(const EvolutionDescription& evolution) {
        return to_vector<unsigned int>(QuantLib::moneyMarketMeasure(evolution));
    }



using QuantLib::MarketModel;
using QuantLib::MarketModelFactory;


using QuantLib::PiecewiseConstantCorrelation;
using QuantLib::ExponentialForwardCorrelation;


using QuantLib::CurveState;
using QuantLib::LMMCurveState;


using QuantLib::LMMDriftCalculator;


using QuantLib::MarketModelEvolver;
using QuantLib::LogNormalFwdRateIpc;

SWIGINTERN std::vector< unsigned int > MarketModelEvolver_numeraires(MarketModelEvolver const *self){
            return to_vector<unsigned int>(self->numeraires());
        }
SWIGINTERN LogNormalFwdRateIpc *new_LogNormalFwdRateIpc__SWIG_0(ext::shared_ptr< MarketModel > const &model,BrownianGeneratorFactory const &factory,std::vector< unsigned int > const &numeraires,Size initialStep=0){
            return new LogNormalFwdRateIpc(model, factory,
                                           to_vector<Size>(numeraires),
                                           initialStep);
        }

using QuantLib::AbcdVol;


using QuantLib::AbcdMathFunction;
using QuantLib::AbcdFunction;


using QuantLib::ContinuousFloatingLookbackOption;
using QuantLib::ContinuousFixedLookbackOption;
using QuantLib::ContinuousPartialFloatingLookbackOption;
using QuantLib::ContinuousPartialFixedLookbackOption;


using QuantLib::AnalyticContinuousFloatingLookbackEngine;
using QuantLib::AnalyticContinuousFixedLookbackEngine;
using QuantLib::AnalyticContinuousPartialFloatingLookbackEngine;
using QuantLib::AnalyticContinuousPartialFixedLookbackEngine;


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


using QuantLib::Path;

SWIGINTERN Path const &Sample_Sl_Path_Sg__value(Sample< Path > *self){ return self->value; }
SWIGINTERN Real Sample_Sl_Path_Sg__weight(Sample< Path > *self){ return self->weight; }

using QuantLib::PathGenerator;


using QuantLib::MultiPath;

SWIGINTERN MultiPath const &Sample_Sl_MultiPath_Sg__value(Sample< MultiPath > *self){ return self->value; }
SWIGINTERN Real Sample_Sl_MultiPath_Sg__weight(Sample< MultiPath > *self){ return self->weight; }

using QuantLib::MultiPathGenerator;

SWIGINTERN MultiPathGenerator< GaussianRandomSequenceGenerator > *new_MultiPathGenerator_Sl_GaussianRandomSequenceGenerator_Sg___SWIG_2(ext::shared_ptr< StochasticProcess > const &process,std::vector< Time > const &times,GaussianRandomSequenceGenerator const &generator,bool brownianBridge=false){
          return new MultiPathGenerator<GaussianRandomSequenceGenerator>(process,
                                             TimeGrid(
                                                 times.begin(),
                                                 times.end()),
                                             generator,
                                             brownianBridge);
      }
SWIGINTERN MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *new_MultiPathGenerator_Sl_GaussianLowDiscrepancySequenceGenerator_Sg___SWIG_2(ext::shared_ptr< StochasticProcess > const &process,std::vector< Time > const &times,GaussianLowDiscrepancySequenceGenerator const &generator,bool brownianBridge=false){
          return new MultiPathGenerator<GaussianLowDiscrepancySequenceGenerator>(process,
                                             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){
        return to_vector<unsigned int>(self->bridgeIndex());
    }
SWIGINTERN std::vector< unsigned int > BrownianBridge_leftIndex(BrownianBridge const *self){
        return to_vector<unsigned int>(self->leftIndex());
    }
SWIGINTERN std::vector< unsigned int > BrownianBridge_rightIndex(BrownianBridge const *self){
        return to_vector<unsigned int>(self->rightIndex());
    }

class OdeFctDelegate {
  public:
    virtual ~OdeFctDelegate() {}
    virtual std::vector<Real> value(
        Real x, const std::vector<Real>& y) const {
                
        QL_FAIL("implementation of OdeFctDelegate.value is missing");
    }
};

class OdeFct {
  public:
    OdeFct(OdeFctDelegate* delegate)
    : delegate_(delegate) { }

    virtual ~OdeFct() { }

    const std::vector<Real> operator()(Real x, const std::vector<Real>& y) const {
        std::vector<Real> retVal = delegate_->value(x, y);
        return retVal;
    }

  private:
    OdeFctDelegate* delegate_;
};


using QuantLib::AdaptiveRungeKutta;

SWIGINTERN double AdaptiveRungeKutta_Sl_Real_Sg__operator_Sp__SP___SWIG_0(AdaptiveRungeKutta< Real > *self,BinaryFunctionDelegate *fct,double y1,Real x1,Real x2){
            BinaryFunction f(fct);
            return self->operator()(f, y1, x1, x2);         
        }
SWIGINTERN std::vector< double > AdaptiveRungeKutta_Sl_Real_Sg__operator_Sp__SP___SWIG_1(AdaptiveRungeKutta< Real > *self,OdeFctDelegate *fct,std::vector< double > const &y1,Real x1,Real x2){            
            OdeFct f(fct);
            return self->operator()(f, y1, x1, x2);
        }

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


using QuantLib::NeumannBC;
using QuantLib::DirichletBC;


using QuantLib::TridiagonalOperator;


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


using QuantLib::HestonSLVProcess;


using QuantLib::HestonSLVMCModel;

SWIGINTERN HestonSLVMCModel *new_HestonSLVMCModel__SWIG_0(ext::shared_ptr< LocalVolTermStructure > const &localVol,ext::shared_ptr< HestonModel > const &model,ext::shared_ptr< BrownianGeneratorFactory > const &brownianGeneratorFactory,Date const &endDate,Size timeStepsPerYear=365,Size nBins=201,Size calibrationPaths=(1 << 15),std::vector< Date > const &mandatoryDates=std::vector< Date >(),Real mixingFactor=1.0){
            return new HestonSLVMCModel(
                Handle<LocalVolTermStructure>(localVol), Handle<HestonModel>(model),
                brownianGeneratorFactory, endDate, timeStepsPerYear,
                nBins, calibrationPaths, mandatoryDates, mixingFactor);
        }

using QuantLib::FdmHestonGreensFct;
using QuantLib::HestonSLVFDMModel;
using QuantLib::HestonSLVFokkerPlanckFdmParams;

SWIGINTERN HestonSLVFokkerPlanckFdmParams *new_HestonSLVFokkerPlanckFdmParams(Size xGrid,Size vGrid,Size tMaxStepsPerYear,Size tMinStepsPerYear,Real tStepNumberDecay,Size nRannacherTimeSteps,Size predictionCorretionSteps,Real x0Density,Real localVolEpsProb,Size maxIntegrationIterations,Real vLowerEps,Real vUpperEps,Real vMin,Real v0Density,Real vLowerBoundDensity,Real vUpperBoundDensity,Real leverageFctPropEps,FdmHestonGreensFct::Algorithm greensAlgorithm,FdmSquareRootFwdOp::TransformationType trafoType,FdmSchemeDesc schemeDesc){
            
                const HestonSLVFokkerPlanckFdmParams params = {
                    xGrid, vGrid,
                    tMaxStepsPerYear, tMinStepsPerYear,
                    tStepNumberDecay,
                    nRannacherTimeSteps,
                    predictionCorretionSteps,
                    x0Density,
                    localVolEpsProb,
                    maxIntegrationIterations,
                    vLowerEps, vUpperEps, vMin,
                    v0Density, vLowerBoundDensity, vUpperBoundDensity,
                    leverageFctPropEps,
                    greensAlgorithm,
                    trafoType,
                    schemeDesc };

                return new HestonSLVFokkerPlanckFdmParams(params);
        }
SWIGINTERN HestonSLVFDMModel *new_HestonSLVFDMModel__SWIG_0(ext::shared_ptr< LocalVolTermStructure > const &localVol,ext::shared_ptr< HestonModel > const &model,Date const &endDate,HestonSLVFokkerPlanckFdmParams const &params,bool const logging=false,std::vector< Date > const &mandatoryDates=std::vector< Date >(),Real mixingFactor=1.0){
            return new HestonSLVFDMModel(
                Handle<LocalVolTermStructure>(localVol), Handle<HestonModel>(model),
                endDate, params, logging, mandatoryDates, mixingFactor);
        }

using QuantLib::SpreadOption;
using QuantLib::KirkSpreadOptionEngine;


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 ext::shared_ptr< Observable > Handle_Sl_CapFloorTermVolatilityStructure_Sg__asObservable(Handle< CapFloorTermVolatilityStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_CapFloorTermVolatilityStructure_Sg__reset(RelinkableHandle< CapFloorTermVolatilityStructure > *self){
            self->linkTo(ext::shared_ptr<CapFloorTermVolatilityStructure>());
        }

using QuantLib::CapFloorTermVolCurve;


using QuantLib::CapFloorTermVolSurface;


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


using QuantLib::StrippedOptionlet;


using QuantLib::OptionletStripper1;


using QuantLib::StrippedOptionletAdapter;


using QuantLib::Actual365Fixed;
using QuantLib::Swaption;
using QuantLib::NonstandardSwaption;
using QuantLib::Settlement;
using QuantLib::FloatFloatSwaption;

SWIGINTERN Real Swaption_vega(Swaption *self){
            return self->result<Real>("vega");
        }
SWIGINTERN Real Swaption_delta(Swaption *self){
            return self->result<Real>("delta");
        }
SWIGINTERN Real Swaption_annuity(Swaption *self){
            return self->result<Real>("annuity");
        }

using QuantLib::BasketGeneratingEngine;

SWIGINTERN std::vector< ext::shared_ptr< BlackCalibrationHelper > > NonstandardSwaption_calibrationBasket(NonstandardSwaption *self,ext::shared_ptr< SwapIndex > swapIndex,ext::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.");

            std::vector<ext::shared_ptr<BlackCalibrationHelper> > hs =
                self->calibrationBasket(swapIndex, swaptionVolatility, type);
            std::vector<ext::shared_ptr<BlackCalibrationHelper> > helpers(hs.size());
            for (Size i=0; i<hs.size(); ++i)
                helpers[i] = hs[i];
            return helpers;
        }
SWIGINTERN std::vector< Real > NonstandardSwaption_probabilities(NonstandardSwaption *self){
            return self->result<std::vector<Real> >("probabilities");
        }
SWIGINTERN std::vector< ext::shared_ptr< BlackCalibrationHelper > > FloatFloatSwaption_calibrationBasket(FloatFloatSwaption *self,ext::shared_ptr< SwapIndex > swapIndex,ext::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.");

        std::vector<ext::shared_ptr<BlackCalibrationHelper> > hs =
            self->calibrationBasket(swapIndex, swaptionVolatility, type);
        std::vector<ext::shared_ptr<BlackCalibrationHelper> > helpers(hs.size());
        for (Size i=0; i<hs.size(); ++i)
            helpers[i] = hs[i];
        return helpers;
        }
SWIGINTERN Real FloatFloatSwaption_underlyingValue(FloatFloatSwaption *self){
            return self->result<Real>("underlyingValue");
        }
SWIGINTERN std::vector< Real > FloatFloatSwaption_probabilities(FloatFloatSwaption *self){
            return self->result<std::vector<Real> >("probabilities");
        }

using QuantLib::BlackSwaptionEngine;
using QuantLib::BachelierSwaptionEngine;


using QuantLib::VanillaSwingOption;


using QuantLib::FdSimpleBSSwingEngine;
using QuantLib::FdSimpleExtOUJumpSwingEngine;

SWIGINTERN FdSimpleExtOUJumpSwingEngine *new_FdSimpleExtOUJumpSwingEngine__SWIG_0(ext::shared_ptr< ExtOUWithJumpsProcess > const &process,ext::shared_ptr< YieldTermStructure > const &rTS,Size tGrid=50,Size xGrid=200,Size yGrid=50,std::vector< std::pair< Time,Real > > const &shape=std::vector< std::pair< Time,Real > >(),FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Hundsdorfer()){

            ext::shared_ptr<FdSimpleExtOUJumpSwingEngine::Shape> curve(
                              new FdSimpleExtOUJumpSwingEngine::Shape(shape));

            return new FdSimpleExtOUJumpSwingEngine(
                    process, rTS, tGrid, xGrid, yGrid,
                    curve, schemeDesc);
        }


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;



/* ---------------------------------------------------
 * 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_BinaryFunctionDelegate::SwigDirector_BinaryFunctionDelegate() : BinaryFunctionDelegate(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_BinaryFunctionDelegate::~SwigDirector_BinaryFunctionDelegate() {
  
}


Real SwigDirector_BinaryFunctionDelegate::value(Real arg0,Real arg1) const {
  Real c_result = SwigValueInit< Real >() ;
  double jresult = 0 ;
  double jarg0  ;
  double jarg1  ;
  
  if (!swig_callbackvalue) {
    return BinaryFunctionDelegate::value(arg0,arg1);
  } else {
    jarg0 = arg0;
    jarg1 = arg1;
    jresult = (double) swig_callbackvalue(jarg0, jarg1);
    c_result = (Real)jresult; 
  }
  return c_result;
}

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

void SwigDirector_BinaryFunctionDelegate::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;
}

SwigDirector_FdmLinearOpCompositeDelegate::SwigDirector_FdmLinearOpCompositeDelegate() : FdmLinearOpCompositeDelegate(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_FdmLinearOpCompositeDelegate::~SwigDirector_FdmLinearOpCompositeDelegate() {
  
}


Size SwigDirector_FdmLinearOpCompositeDelegate::size() const {
  Size c_result = SwigValueInit< Size >() ;
  unsigned long jresult = 0 ;
  
  if (!swig_callbacksize) {
    return FdmLinearOpCompositeDelegate::size();
  } else {
    jresult = (unsigned long) swig_callbacksize();
    c_result = (Size)jresult; 
  }
  return c_result;
}

void SwigDirector_FdmLinearOpCompositeDelegate::setTime(Time t1,Time t2) {
  double jt1  ;
  double jt2  ;
  
  if (!swig_callbacksetTime) {
    FdmLinearOpCompositeDelegate::setTime(t1,t2);
    return;
  } else {
    jt1 = t1;
    jt2 = t2;
    swig_callbacksetTime(jt1, jt2);
  }
}

Array SwigDirector_FdmLinearOpCompositeDelegate::apply(Array const &r) const {
  Array c_result ;
  void * jresult = 0 ;
  void * jr = 0 ;
  
  if (!swig_callbackapply) {
    return FdmLinearOpCompositeDelegate::apply(r);
  } else {
    jr = (Array *) &r; 
    jresult = (void *) swig_callbackapply(jr);
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Array", 0);
      return c_result;
    }
    c_result = *(Array *)jresult; 
  }
  return c_result;
}

Array SwigDirector_FdmLinearOpCompositeDelegate::apply_mixed(Array const &r) const {
  Array c_result ;
  void * jresult = 0 ;
  void * jr = 0 ;
  
  if (!swig_callbackapply_mixed) {
    return FdmLinearOpCompositeDelegate::apply_mixed(r);
  } else {
    jr = (Array *) &r; 
    jresult = (void *) swig_callbackapply_mixed(jr);
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Array", 0);
      return c_result;
    }
    c_result = *(Array *)jresult; 
  }
  return c_result;
}

Array SwigDirector_FdmLinearOpCompositeDelegate::apply_direction(Size direction,Array const &r) const {
  Array c_result ;
  void * jresult = 0 ;
  unsigned long jdirection  ;
  void * jr = 0 ;
  
  if (!swig_callbackapply_direction) {
    return FdmLinearOpCompositeDelegate::apply_direction(direction,r);
  } else {
    jdirection = (unsigned long)direction;
    jr = (Array *) &r; 
    jresult = (void *) swig_callbackapply_direction(jdirection, jr);
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Array", 0);
      return c_result;
    }
    c_result = *(Array *)jresult; 
  }
  return c_result;
}

Array SwigDirector_FdmLinearOpCompositeDelegate::solve_splitting(Size direction,Array const &r,Real s) const {
  Array c_result ;
  void * jresult = 0 ;
  unsigned long jdirection  ;
  void * jr = 0 ;
  double js  ;
  
  if (!swig_callbacksolve_splitting) {
    return FdmLinearOpCompositeDelegate::solve_splitting(direction,r,s);
  } else {
    jdirection = (unsigned long)direction;
    jr = (Array *) &r; 
    js = s;
    jresult = (void *) swig_callbacksolve_splitting(jdirection, jr, js);
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Array", 0);
      return c_result;
    }
    c_result = *(Array *)jresult; 
  }
  return c_result;
}

Array SwigDirector_FdmLinearOpCompositeDelegate::preconditioner(Array const &r,Real dt) const {
  Array c_result ;
  void * jresult = 0 ;
  void * jr = 0 ;
  double jdt  ;
  
  if (!swig_callbackpreconditioner) {
    return FdmLinearOpCompositeDelegate::preconditioner(r,dt);
  } else {
    jr = (Array *) &r; 
    jdt = dt;
    jresult = (void *) swig_callbackpreconditioner(jr, jdt);
    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_FdmLinearOpCompositeDelegate::swig_connect_director(SWIG_Callback0_t callbacksize, SWIG_Callback1_t callbacksetTime, SWIG_Callback2_t callbackapply, SWIG_Callback3_t callbackapply_mixed, SWIG_Callback4_t callbackapply_direction, SWIG_Callback5_t callbacksolve_splitting, SWIG_Callback6_t callbackpreconditioner) {
  swig_callbacksize = callbacksize;
  swig_callbacksetTime = callbacksetTime;
  swig_callbackapply = callbackapply;
  swig_callbackapply_mixed = callbackapply_mixed;
  swig_callbackapply_direction = callbackapply_direction;
  swig_callbacksolve_splitting = callbacksolve_splitting;
  swig_callbackpreconditioner = callbackpreconditioner;
}

void SwigDirector_FdmLinearOpCompositeDelegate::swig_init_callbacks() {
  swig_callbacksize = 0;
  swig_callbacksetTime = 0;
  swig_callbackapply = 0;
  swig_callbackapply_mixed = 0;
  swig_callbackapply_direction = 0;
  swig_callbacksolve_splitting = 0;
  swig_callbackpreconditioner = 0;
}

SwigDirector_FdmStepConditionDelegate::SwigDirector_FdmStepConditionDelegate() : FdmStepConditionDelegate(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_FdmStepConditionDelegate::~SwigDirector_FdmStepConditionDelegate() {
  
}


void SwigDirector_FdmStepConditionDelegate::applyTo(Array &a,Time t) const {
  void * ja = 0 ;
  double jt  ;
  
  if (!swig_callbackapplyTo) {
    FdmStepConditionDelegate::applyTo(a,t);
    return;
  } else {
    ja = (Array *) &a; 
    jt = t;
    swig_callbackapplyTo(ja, jt);
  }
}

void SwigDirector_FdmStepConditionDelegate::swig_connect_director(SWIG_Callback0_t callbackapplyTo) {
  swig_callbackapplyTo = callbackapplyTo;
}

void SwigDirector_FdmStepConditionDelegate::swig_init_callbacks() {
  swig_callbackapplyTo = 0;
}

SwigDirector_FdmInnerValueCalculatorDelegate::SwigDirector_FdmInnerValueCalculatorDelegate() : FdmInnerValueCalculatorDelegate(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_FdmInnerValueCalculatorDelegate::~SwigDirector_FdmInnerValueCalculatorDelegate() {
  
}


Real SwigDirector_FdmInnerValueCalculatorDelegate::innerValue(FdmLinearOpIterator const &iter,Time t) {
  Real c_result = SwigValueInit< Real >() ;
  double jresult = 0 ;
  void * jiter = 0 ;
  double jt  ;
  
  if (!swig_callbackinnerValue) {
    return FdmInnerValueCalculatorDelegate::innerValue(iter,t);
  } else {
    jiter = (FdmLinearOpIterator *) &iter; 
    jt = t;
    jresult = (double) swig_callbackinnerValue(jiter, jt);
    c_result = (Real)jresult; 
  }
  return c_result;
}

Real SwigDirector_FdmInnerValueCalculatorDelegate::avgInnerValue(FdmLinearOpIterator const &iter,Time t) {
  Real c_result = SwigValueInit< Real >() ;
  double jresult = 0 ;
  void * jiter = 0 ;
  double jt  ;
  
  if (!swig_callbackavgInnerValue) {
    return FdmInnerValueCalculatorDelegate::avgInnerValue(iter,t);
  } else {
    jiter = (FdmLinearOpIterator *) &iter; 
    jt = t;
    jresult = (double) swig_callbackavgInnerValue(jiter, jt);
    c_result = (Real)jresult; 
  }
  return c_result;
}

void SwigDirector_FdmInnerValueCalculatorDelegate::swig_connect_director(SWIG_Callback0_t callbackinnerValue, SWIG_Callback1_t callbackavgInnerValue) {
  swig_callbackinnerValue = callbackinnerValue;
  swig_callbackavgInnerValue = callbackavgInnerValue;
}

void SwigDirector_FdmInnerValueCalculatorDelegate::swig_init_callbacks() {
  swig_callbackinnerValue = 0;
  swig_callbackavgInnerValue = 0;
}

SwigDirector_OdeFctDelegate::SwigDirector_OdeFctDelegate() : OdeFctDelegate(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_OdeFctDelegate::~SwigDirector_OdeFctDelegate() {
  
}


std::vector< Real > SwigDirector_OdeFctDelegate::value(Real x,std::vector< Real > const &y) const {
  std::vector< Real > c_result ;
  void * jresult = 0 ;
  double jx  ;
  void * jy = 0 ;
  
  if (!swig_callbackvalue) {
    return OdeFctDelegate::value(x,y);
  } else {
    jx = x;
    jy = (std::vector< Real > *) &y; 
    jresult = (void *) swig_callbackvalue(jx, jy);
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type std::vector< Real >", 0);
      return c_result;
    }
    c_result = *(std::vector< Real > *)jresult; 
  }
  return c_result;
}

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

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


#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionalBool(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  ext::optional< bool > *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (ext::optional< bool > *)new ext::optional< bool >(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_OptionalBool(void * jarg1) {
  ext::optional< bool > *arg1 = (ext::optional< bool > *) 0 ;
  
  arg1 = (ext::optional< 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_OptionalFrequency(int jarg1) {
  void * jresult ;
  Frequency arg1 ;
  ext::optional< Frequency > *result = 0 ;
  
  arg1 = (Frequency)jarg1; 
  {
    try {
      result = (ext::optional< Frequency > *)new ext::optional< Frequency >(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


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_Period_normalized(void * jarg1) {
  void * jresult ;
  Period *arg1 = (Period *) 0 ;
  Period result;
  
  arg1 = (Period *)jarg1; 
  {
    try {
      result = ((Period const *)arg1)->normalized();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Period__SWIG_3(const 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 const char * SWIGSTDCALL CSharp_QuantLib_Period___str__(void * jarg1) {
  const 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 const char * SWIGSTDCALL CSharp_QuantLib_Period___repr__(void * jarg1) {
  const 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 int SWIGSTDCALL CSharp_QuantLib_Period_compareTo(void * jarg1, void * jarg2) {
  int jresult ;
  Period *arg1 = 0 ;
  Period *arg2 = 0 ;
  int result;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)Period_compareTo((Period const &)*arg1,(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 = result; 
  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 & 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 & 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(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 ;
  std::vector< Period >::value_type *result = 0 ;
  
  arg1 = (std::vector< Period > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< Period >::value_type *) &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 & 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 & 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 & 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 & 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 & 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 & 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(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(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(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(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(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 & 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(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 & 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 & 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(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(SWIG_STD_MOVE(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(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(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(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 & 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(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 & 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Date__SWIG_6(const char * jarg1, const 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,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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 const char * SWIGSTDCALL CSharp_QuantLib_Date___str__(void * jarg1) {
  const 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 const char * SWIGSTDCALL CSharp_QuantLib_Date___repr__(void * jarg1) {
  const 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 const char * SWIGSTDCALL CSharp_QuantLib_Date_ISO(void * jarg1) {
  const 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 long SWIGSTDCALL CSharp_QuantLib_Date_Subtract__SWIG_2(void * jarg1, void * jarg2) {
  long jresult ;
  Date *arg1 = (Date *) 0 ;
  Date *arg2 = 0 ;
  BigInteger result;
  
  arg1 = (Date *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BigInteger)Date_operator_Ss___SWIG_2(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_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(const char * jarg1, const 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DateParser_parseISO(const 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DateParser_parse(const char * jarg1, const 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,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(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(const 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(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 & 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 & 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(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 ;
  std::vector< Date >::value_type *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< Date >::value_type *) &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 & 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 & 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 & 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 & 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 & 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 & 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 double SWIGSTDCALL CSharp_QuantLib_daysBetween(void * jarg1, void * jarg2) {
  double jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Time result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)daysBetween((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 = result; 
  return jresult;
}


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 & 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 & 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(const 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(const 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 const char * SWIGSTDCALL CSharp_QuantLib_IMM_code(void * jarg1) {
  const char * jresult ;
  Date *arg1 = 0 ;
  std::string result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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(const 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 & 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IMM_date__SWIG_1(const 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(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 & 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(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 & 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(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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IMM_nextDate__SWIG_3(const 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 & 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IMM_nextDate__SWIG_4(const 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IMM_nextDate__SWIG_5(const 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(result); 
  return jresult;
}


SWIGEXPORT const char * SWIGSTDCALL CSharp_QuantLib_IMM_nextCode__SWIG_0(void * jarg1, unsigned int jarg2) {
  const char * jresult ;
  Date *arg1 = 0 ;
  bool arg2 ;
  std::string result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 const char * SWIGSTDCALL CSharp_QuantLib_IMM_nextCode__SWIG_1(void * jarg1) {
  const char * jresult ;
  Date *arg1 = 0 ;
  std::string result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 const char * SWIGSTDCALL CSharp_QuantLib_IMM_nextCode__SWIG_2() {
  const 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 const char * SWIGSTDCALL CSharp_QuantLib_IMM_nextCode__SWIG_3(const char * jarg1, unsigned int jarg2, void * jarg3) {
  const 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 & 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 const char * SWIGSTDCALL CSharp_QuantLib_IMM_nextCode__SWIG_4(const char * jarg1, unsigned int jarg2) {
  const 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 const char * SWIGSTDCALL CSharp_QuantLib_IMM_nextCode__SWIG_5(const char * jarg1) {
  const 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 & 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 & 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(const 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(const 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 const char * SWIGSTDCALL CSharp_QuantLib_ASX_code(void * jarg1) {
  const char * jresult ;
  Date *arg1 = 0 ;
  std::string result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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(const 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 & 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ASX_date__SWIG_1(const 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(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 & 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(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 & 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(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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ASX_nextDate__SWIG_3(const 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 & 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ASX_nextDate__SWIG_4(const 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ASX_nextDate__SWIG_5(const 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(result); 
  return jresult;
}


SWIGEXPORT const char * SWIGSTDCALL CSharp_QuantLib_ASX_nextCode__SWIG_0(void * jarg1, unsigned int jarg2) {
  const char * jresult ;
  Date *arg1 = 0 ;
  bool arg2 ;
  std::string result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 const char * SWIGSTDCALL CSharp_QuantLib_ASX_nextCode__SWIG_1(void * jarg1) {
  const char * jresult ;
  Date *arg1 = 0 ;
  std::string result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 const char * SWIGSTDCALL CSharp_QuantLib_ASX_nextCode__SWIG_2() {
  const 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 const char * SWIGSTDCALL CSharp_QuantLib_ASX_nextCode__SWIG_3(const char * jarg1, unsigned int jarg2, void * jarg3) {
  const 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 & 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 const char * SWIGSTDCALL CSharp_QuantLib_ASX_nextCode__SWIG_4(const char * jarg1, unsigned int jarg2) {
  const 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 const char * SWIGSTDCALL CSharp_QuantLib_ASX_nextCode__SWIG_5(const char * jarg1) {
  const 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 & 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 ;
  std::vector< int >::value_type *result = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< int >::value_type *) &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 & 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 & 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 & 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 & 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 ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< unsigned int >::value_type *) &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 & 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 & 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 & 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 & 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 ;
  std::vector< double >::value_type *result = 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< double >::value_type *) &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 & 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 & 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 & 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, const 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 & 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 const char * SWIGSTDCALL CSharp_QuantLib_StrVector_getitemcopy(void * jarg1, int jarg2) {
  const 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 const char * SWIGSTDCALL CSharp_QuantLib_StrVector_getitem(void * jarg1, int jarg2) {
  const char * jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::vector< std::string >::value_type *result = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::string >::value_type *) &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, const 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 & 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, const 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 & 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(const 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 & 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, const 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, const 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, const 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, const 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 & 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 & 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 & 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 & 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_DoubleVectorVector_Clear(void * jarg1) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  
  arg1 = (std::vector< 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_DoubleVectorVector_Add(void * jarg1, void * jarg2) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< double > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1; 
  arg2 = (std::vector< double > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((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 unsigned long SWIGSTDCALL CSharp_QuantLib_DoubleVectorVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::size_type result;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1; 
  {
    try {
      result = ((std::vector< 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_DoubleVectorVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::size_type result;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1; 
  {
    try {
      result = ((std::vector< 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_DoubleVectorVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::size_type arg2 ;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1; 
  arg2 = (std::vector< 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_DoubleVectorVector__SWIG_0() {
  void * jresult ;
  std::vector< std::vector< double > > *result = 0 ;
  
  {
    try {
      result = (std::vector< std::vector< double > > *)new std::vector< 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_DoubleVectorVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< double > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< std::vector< double > > *)new std::vector< std::vector< double > >((std::vector< 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_DoubleVectorVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< std::vector< double > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< std::vector< double > > *)new_std_vector_Sl_std_vector_Sl_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_DoubleVectorVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  int arg2 ;
  std::vector< double > result;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_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::vector< double >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DoubleVectorVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< double > >::value_type *result = 0 ;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::vector< double > >::value_type *) &std_vector_Sl_std_vector_Sl_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_DoubleVectorVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  int arg2 ;
  std::vector< double > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< double > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg__setitem(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_DoubleVectorVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1; 
  arg2 = (std::vector< std::vector< double > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< double > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_std_vector_Sl_double_Sg__Sg__AddRange(arg1,(std::vector< 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_DoubleVectorVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::vector< double > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< std::vector< double > > *)std_vector_Sl_std_vector_Sl_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_DoubleVectorVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  int arg2 ;
  std::vector< double > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< double > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg__Insert(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_DoubleVectorVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< double > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< double > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< double > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg__InsertRange(arg1,arg2,(std::vector< 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_DoubleVectorVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_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_DoubleVectorVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_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_DoubleVectorVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< double > *arg1 = 0 ;
  int arg2 ;
  std::vector< std::vector< double > > *result = 0 ;
  
  arg1 = (std::vector< double > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::vector< double > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg__Repeat((std::vector< 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_DoubleVectorVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1; 
  {
    try {
      std_vector_Sl_std_vector_Sl_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_DoubleVectorVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_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_DoubleVectorVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< double > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< double > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< double > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg__SetRange(arg1,arg2,(std::vector< 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_delete_DoubleVectorVector(void * jarg1) {
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  
  arg1 = (std::vector< 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_new_DoublePair__SWIG_0() {
  void * jresult ;
  std::pair< double,double > *result = 0 ;
  
  {
    try {
      result = (std::pair< double,double > *)new std::pair< double,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_DoublePair__SWIG_1(double jarg1, double jarg2) {
  void * jresult ;
  double arg1 ;
  double arg2 ;
  std::pair< double,double > *result = 0 ;
  
  arg1 = (double)jarg1; 
  arg2 = (double)jarg2; 
  {
    try {
      result = (std::pair< double,double > *)new std::pair< double,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_DoublePair__SWIG_2(void * jarg1) {
  void * jresult ;
  std::pair< double,double > *arg1 = 0 ;
  std::pair< double,double > *result = 0 ;
  
  arg1 = (std::pair< double,double > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< double,double > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::pair< double,double > *)new std::pair< double,double >((std::pair< double,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_DoublePair_first_set(void * jarg1, double jarg2) {
  std::pair< double,double > *arg1 = (std::pair< double,double > *) 0 ;
  double arg2 ;
  
  arg1 = (std::pair< double,double > *)jarg1; 
  arg2 = (double)jarg2; 
  if (arg1) (arg1)->first = arg2;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DoublePair_first_get(void * jarg1) {
  double jresult ;
  std::pair< double,double > *arg1 = (std::pair< double,double > *) 0 ;
  double result;
  
  arg1 = (std::pair< double,double > *)jarg1; 
  result = (double) ((arg1)->first);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DoublePair_second_set(void * jarg1, double jarg2) {
  std::pair< double,double > *arg1 = (std::pair< double,double > *) 0 ;
  double arg2 ;
  
  arg1 = (std::pair< double,double > *)jarg1; 
  arg2 = (double)jarg2; 
  if (arg1) (arg1)->second = arg2;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DoublePair_second_get(void * jarg1) {
  double jresult ;
  std::pair< double,double > *arg1 = (std::pair< double,double > *) 0 ;
  double result;
  
  arg1 = (std::pair< double,double > *)jarg1; 
  result = (double) ((arg1)->second);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DoublePair(void * jarg1) {
  std::pair< double,double > *arg1 = (std::pair< double,double > *) 0 ;
  
  arg1 = (std::pair< double,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_DoublePairVector_Clear(void * jarg1) {
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  
  arg1 = (std::vector< std::pair< double,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_DoublePairVector_Add(void * jarg1, void * jarg2) {
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::pair< double,double > *arg2 = 0 ;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1; 
  arg2 = (std::pair< double,double > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< double,double > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::pair< double,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_DoublePairVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::size_type result;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1; 
  {
    try {
      result = ((std::vector< std::pair< double,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_DoublePairVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::size_type result;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1; 
  {
    try {
      result = ((std::vector< std::pair< double,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_DoublePairVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::size_type arg2 ;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1; 
  arg2 = (std::vector< std::pair< double,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_DoublePairVector__SWIG_0() {
  void * jresult ;
  std::vector< std::pair< double,double > > *result = 0 ;
  
  {
    try {
      result = (std::vector< std::pair< double,double > > *)new std::vector< std::pair< double,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_DoublePairVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< std::pair< double,double > > *arg1 = 0 ;
  std::vector< std::pair< double,double > > *result = 0 ;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< double,double > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< std::pair< double,double > > *)new std::vector< std::pair< double,double > >((std::vector< std::pair< double,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_DoublePairVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< std::pair< double,double > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< std::pair< double,double > > *)new_std_vector_Sl_std_pair_Sl_double_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_DoublePairVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  int arg2 ;
  std::pair< double,double > result;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_double_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< double,double >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DoublePairVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< double,double > >::value_type *result = 0 ;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< double,double > >::value_type *) &std_vector_Sl_std_pair_Sl_double_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_DoublePairVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  int arg2 ;
  std::pair< double,double > *arg3 = 0 ;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::pair< double,double > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< double,double > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__setitem(arg1,arg2,(std::pair< double,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_DoublePairVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1; 
  arg2 = (std::vector< std::pair< double,double > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< double,double > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__AddRange(arg1,(std::vector< std::pair< double,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_DoublePairVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::pair< double,double > > *result = 0 ;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< std::pair< double,double > > *)std_vector_Sl_std_pair_Sl_double_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_DoublePairVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  int arg2 ;
  std::pair< double,double > *arg3 = 0 ;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::pair< double,double > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< double,double > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__Insert(arg1,arg2,(std::pair< double,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_DoublePairVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< double,double > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::pair< double,double > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< double,double > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::pair< double,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_DoublePairVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_double_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_DoublePairVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_double_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_DoublePairVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  std::pair< double,double > *arg1 = 0 ;
  int arg2 ;
  std::vector< std::pair< double,double > > *result = 0 ;
  
  arg1 = (std::pair< double,double > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< double,double > const & is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< double,double > > *)std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__Repeat((std::pair< double,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_DoublePairVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1; 
  {
    try {
      std_vector_Sl_std_pair_Sl_double_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_DoublePairVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_double_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_DoublePairVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< double,double > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::pair< double,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::pair< double,double > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< double,double > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__SetRange(arg1,arg2,(std::vector< std::pair< double,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_delete_DoublePairVector(void * jarg1) {
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  
  arg1 = (std::vector< std::pair< double,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_new_PairDoubleVector__SWIG_0() {
  void * jresult ;
  std::pair< std::vector< double >,std::vector< double > > *result = 0 ;
  
  {
    try {
      result = (std::pair< std::vector< double >,std::vector< double > > *)new std::pair< std::vector< double >,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_PairDoubleVector__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< double > arg1 ;
  std::vector< double > arg2 ;
  std::vector< double > *argp1 ;
  std::vector< double > *argp2 ;
  std::pair< std::vector< double >,std::vector< double > > *result = 0 ;
  
  argp1 = (std::vector< double > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< double >", 0);
    return 0;
  }
  arg1 = *argp1; 
  argp2 = (std::vector< double > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< double >", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (std::pair< std::vector< double >,std::vector< double > > *)new std::pair< std::vector< double >,std::vector< 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_PairDoubleVector__SWIG_2(void * jarg1) {
  void * jresult ;
  std::pair< std::vector< double >,std::vector< double > > *arg1 = 0 ;
  std::pair< std::vector< double >,std::vector< double > > *result = 0 ;
  
  arg1 = (std::pair< std::vector< double >,std::vector< double > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::vector< double >,std::vector< double > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::pair< std::vector< double >,std::vector< double > > *)new std::pair< std::vector< double >,std::vector< double > >((std::pair< 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_PairDoubleVector_first_set(void * jarg1, void * jarg2) {
  std::pair< std::vector< double >,std::vector< double > > *arg1 = (std::pair< std::vector< double >,std::vector< double > > *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  
  arg1 = (std::pair< std::vector< double >,std::vector< double > > *)jarg1; 
  arg2 = (std::vector< double > *)jarg2; 
  if (arg1) (arg1)->first = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PairDoubleVector_first_get(void * jarg1) {
  void * jresult ;
  std::pair< std::vector< double >,std::vector< double > > *arg1 = (std::pair< std::vector< double >,std::vector< double > > *) 0 ;
  std::vector< double > *result = 0 ;
  
  arg1 = (std::pair< std::vector< double >,std::vector< double > > *)jarg1; 
  result = (std::vector< double > *)& ((arg1)->first);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PairDoubleVector_second_set(void * jarg1, void * jarg2) {
  std::pair< std::vector< double >,std::vector< double > > *arg1 = (std::pair< std::vector< double >,std::vector< double > > *) 0 ;
  std::vector< double > *arg2 = (std::vector< double > *) 0 ;
  
  arg1 = (std::pair< std::vector< double >,std::vector< double > > *)jarg1; 
  arg2 = (std::vector< double > *)jarg2; 
  if (arg1) (arg1)->second = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PairDoubleVector_second_get(void * jarg1) {
  void * jresult ;
  std::pair< std::vector< double >,std::vector< double > > *arg1 = (std::pair< std::vector< double >,std::vector< double > > *) 0 ;
  std::vector< double > *result = 0 ;
  
  arg1 = (std::pair< std::vector< double >,std::vector< double > > *)jarg1; 
  result = (std::vector< double > *)& ((arg1)->second);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PairDoubleVector(void * jarg1) {
  std::pair< std::vector< double >,std::vector< double > > *arg1 = (std::pair< std::vector< double >,std::vector< double > > *) 0 ;
  
  arg1 = (std::pair< std::vector< double >,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_new_UnsignedIntPair__SWIG_0() {
  void * jresult ;
  std::pair< unsigned int,unsigned int > *result = 0 ;
  
  {
    try {
      result = (std::pair< unsigned int,unsigned int > *)new std::pair< unsigned int,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_UnsignedIntPair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
  void * jresult ;
  unsigned int arg1 ;
  unsigned int arg2 ;
  std::pair< unsigned int,unsigned int > *result = 0 ;
  
  arg1 = (unsigned int)jarg1; 
  arg2 = (unsigned int)jarg2; 
  {
    try {
      result = (std::pair< unsigned int,unsigned int > *)new std::pair< unsigned int,unsigned int >(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_UnsignedIntPair__SWIG_2(void * jarg1) {
  void * jresult ;
  std::pair< unsigned int,unsigned int > *arg1 = 0 ;
  std::pair< unsigned int,unsigned int > *result = 0 ;
  
  arg1 = (std::pair< unsigned int,unsigned int > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,unsigned int > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::pair< unsigned int,unsigned int > *)new std::pair< unsigned int,unsigned int >((std::pair< unsigned int,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_UnsignedIntPair_first_set(void * jarg1, unsigned int jarg2) {
  std::pair< unsigned int,unsigned int > *arg1 = (std::pair< unsigned int,unsigned int > *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (std::pair< unsigned int,unsigned int > *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->first = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_UnsignedIntPair_first_get(void * jarg1) {
  unsigned int jresult ;
  std::pair< unsigned int,unsigned int > *arg1 = (std::pair< unsigned int,unsigned int > *) 0 ;
  unsigned int result;
  
  arg1 = (std::pair< unsigned int,unsigned int > *)jarg1; 
  result = (unsigned int) ((arg1)->first);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_UnsignedIntPair_second_set(void * jarg1, unsigned int jarg2) {
  std::pair< unsigned int,unsigned int > *arg1 = (std::pair< unsigned int,unsigned int > *) 0 ;
  unsigned int arg2 ;
  
  arg1 = (std::pair< unsigned int,unsigned int > *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->second = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_UnsignedIntPair_second_get(void * jarg1) {
  unsigned int jresult ;
  std::pair< unsigned int,unsigned int > *arg1 = (std::pair< unsigned int,unsigned int > *) 0 ;
  unsigned int result;
  
  arg1 = (std::pair< unsigned int,unsigned int > *)jarg1; 
  result = (unsigned int) ((arg1)->second);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UnsignedIntPair(void * jarg1) {
  std::pair< unsigned int,unsigned int > *arg1 = (std::pair< unsigned int,unsigned int > *) 0 ;
  
  arg1 = (std::pair< unsigned int,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_UnsignedIntPairVector_Clear(void * jarg1) {
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  
  arg1 = (std::vector< std::pair< unsigned int,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_UnsignedIntPairVector_Add(void * jarg1, void * jarg2) {
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::pair< unsigned int,unsigned int > *arg2 = 0 ;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1; 
  arg2 = (std::pair< unsigned int,unsigned int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,unsigned int > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::pair< unsigned int,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_UnsignedIntPairVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type result;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1; 
  {
    try {
      result = ((std::vector< std::pair< unsigned int,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_UnsignedIntPairVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type result;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1; 
  {
    try {
      result = ((std::vector< std::pair< unsigned int,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_UnsignedIntPairVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type arg2 ;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1; 
  arg2 = (std::vector< std::pair< unsigned int,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_UnsignedIntPairVector__SWIG_0() {
  void * jresult ;
  std::vector< std::pair< unsigned int,unsigned int > > *result = 0 ;
  
  {
    try {
      result = (std::vector< std::pair< unsigned int,unsigned int > > *)new std::vector< std::pair< unsigned int,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_UnsignedIntPairVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = 0 ;
  std::vector< std::pair< unsigned int,unsigned int > > *result = 0 ;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,unsigned int > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< std::pair< unsigned int,unsigned int > > *)new std::vector< std::pair< unsigned int,unsigned int > >((std::vector< std::pair< unsigned int,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_UnsignedIntPairVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< std::pair< unsigned int,unsigned int > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< std::pair< unsigned int,unsigned int > > *)new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_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_UnsignedIntPairVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  int arg2 ;
  std::pair< unsigned int,unsigned int > result;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_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< unsigned int,unsigned int >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_UnsignedIntPairVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *result = 0 ;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< unsigned int,unsigned int > >::value_type *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_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_UnsignedIntPairVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  int arg2 ;
  std::pair< unsigned int,unsigned int > *arg3 = 0 ;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::pair< unsigned int,unsigned int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,unsigned int > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__setitem(arg1,arg2,(std::pair< unsigned int,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_UnsignedIntPairVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1; 
  arg2 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,unsigned int > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__AddRange(arg1,(std::vector< std::pair< unsigned int,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_UnsignedIntPairVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::pair< unsigned int,unsigned int > > *result = 0 ;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< std::pair< unsigned int,unsigned int > > *)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_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_UnsignedIntPairVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  int arg2 ;
  std::pair< unsigned int,unsigned int > *arg3 = 0 ;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::pair< unsigned int,unsigned int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,unsigned int > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__Insert(arg1,arg2,(std::pair< unsigned int,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_UnsignedIntPairVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,unsigned int > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::pair< unsigned int,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_UnsignedIntPairVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_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_UnsignedIntPairVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_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_UnsignedIntPairVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  std::pair< unsigned int,unsigned int > *arg1 = 0 ;
  int arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > > *result = 0 ;
  
  arg1 = (std::pair< unsigned int,unsigned int > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,unsigned int > const & is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< unsigned int,unsigned int > > *)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__Repeat((std::pair< unsigned int,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_UnsignedIntPairVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1; 
  {
    try {
      std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_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_UnsignedIntPairVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_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_UnsignedIntPairVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,unsigned int > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__SetRange(arg1,arg2,(std::vector< std::pair< unsigned int,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_delete_UnsignedIntPairVector(void * jarg1) {
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  
  arg1 = (std::vector< std::pair< unsigned int,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_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 & 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 & 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 & 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 >(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::vector< std::pair< Date,double > >::value_type *result = 0 ;
  
  arg1 = (std::vector< std::pair< Date,double > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< Date,double > >::value_type *) &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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 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 & 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(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 & 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 & 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 & 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 & 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 & 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_resetAddedAndRemovedHolidays(void * jarg1) {
  Calendar *arg1 = (Calendar *) 0 ;
  
  arg1 = (Calendar *)jarg1; 
  {
    try {
      (arg1)->resetAddedAndRemovedHolidays();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 & 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(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 & 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(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 & 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(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 & 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(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 & 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(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 & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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(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 & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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(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 & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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(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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 void * SWIGSTDCALL CSharp_QuantLib_Calendar_holidayList__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  bool arg4 ;
  std::vector< Date > result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (arg1)->holidayList((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 = new std::vector< Date >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Calendar_holidayList__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  std::vector< Date > result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (arg1)->holidayList((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 = new std::vector< Date >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Calendar_businessDayList(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  std::vector< Date > result;
  
  arg1 = (Calendar *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (arg1)->businessDayList((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 = new std::vector< Date >(result); 
  return jresult;
}


SWIGEXPORT const char * SWIGSTDCALL CSharp_QuantLib_Calendar_name(void * jarg1) {
  const 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 const char * SWIGSTDCALL CSharp_QuantLib_Calendar___str__(void * jarg1) {
  const 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_CalendarVector_Clear(void * jarg1) {
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  
  arg1 = (std::vector< Calendar > *)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_CalendarVector_Add(void * jarg1, void * jarg2) {
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  Calendar *arg2 = 0 ;
  
  arg1 = (std::vector< Calendar > *)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((Calendar 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_CalendarVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::size_type result;
  
  arg1 = (std::vector< Calendar > *)jarg1; 
  {
    try {
      result = ((std::vector< Calendar > 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_CalendarVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::size_type result;
  
  arg1 = (std::vector< Calendar > *)jarg1; 
  {
    try {
      result = ((std::vector< Calendar > 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_CalendarVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::size_type arg2 ;
  
  arg1 = (std::vector< Calendar > *)jarg1; 
  arg2 = (std::vector< Calendar >::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_CalendarVector__SWIG_0() {
  void * jresult ;
  std::vector< Calendar > *result = 0 ;
  
  {
    try {
      result = (std::vector< Calendar > *)new std::vector< 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 = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CalendarVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< Calendar > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< Calendar > *)new_std_vector_Sl_Calendar_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_CalendarVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  int arg2 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (std::vector< Calendar > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_Calendar_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 Calendar(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalendarVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  int arg2 ;
  std::vector< Calendar >::value_type *result = 0 ;
  
  arg1 = (std::vector< Calendar > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< Calendar >::value_type *) &std_vector_Sl_Calendar_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_CalendarVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  int arg2 ;
  Calendar *arg3 = 0 ;
  
  arg1 = (std::vector< Calendar > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Calendar_Sg__setitem(arg1,arg2,(Calendar 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_CalendarVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar > *arg2 = 0 ;
  
  arg1 = (std::vector< Calendar > *)jarg1; 
  arg2 = (std::vector< Calendar > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Calendar > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_Calendar_Sg__AddRange(arg1,(std::vector< Calendar > 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_CalendarVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< Calendar > *result = 0 ;
  
  arg1 = (std::vector< Calendar > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< Calendar > *)std_vector_Sl_Calendar_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_CalendarVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  int arg2 ;
  Calendar *arg3 = 0 ;
  
  arg1 = (std::vector< Calendar > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Calendar_Sg__Insert(arg1,arg2,(Calendar 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_CalendarVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  int arg2 ;
  std::vector< Calendar > *arg3 = 0 ;
  
  arg1 = (std::vector< Calendar > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< Calendar > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Calendar > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Calendar_Sg__InsertRange(arg1,arg2,(std::vector< Calendar > 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_CalendarVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< Calendar > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_Calendar_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_CalendarVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< Calendar > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_Calendar_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_CalendarVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  Calendar *arg1 = 0 ;
  int arg2 ;
  std::vector< Calendar > *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< Calendar > *)std_vector_Sl_Calendar_Sg__Repeat((Calendar 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_CalendarVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  
  arg1 = (std::vector< Calendar > *)jarg1; 
  {
    try {
      std_vector_Sl_Calendar_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_CalendarVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< Calendar > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_Calendar_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_CalendarVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  int arg2 ;
  std::vector< Calendar > *arg3 = 0 ;
  
  arg1 = (std::vector< Calendar > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< Calendar > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Calendar > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Calendar_Sg__SetRange(arg1,arg2,(std::vector< Calendar > 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_CalendarVector(void * jarg1) {
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  
  arg1 = (std::vector< 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__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Australia::Market arg1 ;
  QuantLib::Australia *result = 0 ;
  
  arg1 = (QuantLib::Australia::Market)jarg1; 
  {
    try {
      result = (QuantLib::Australia *)new QuantLib::Australia(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Australia__SWIG_1() {
  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_Austria__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Austria::Market arg1 ;
  QuantLib::Austria *result = 0 ;
  
  arg1 = (QuantLib::Austria::Market)jarg1; 
  {
    try {
      result = (QuantLib::Austria *)new QuantLib::Austria(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


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


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Botswana(void * jarg1) {
  QuantLib::Botswana *arg1 = (QuantLib::Botswana *) 0 ;
  
  arg1 = (QuantLib::Botswana *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_Chile__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Chile::Market arg1 ;
  QuantLib::Chile *result = 0 ;
  
  arg1 = (QuantLib::Chile::Market)jarg1; 
  {
    try {
      result = (QuantLib::Chile *)new QuantLib::Chile(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Chile(void * jarg1) {
  QuantLib::Chile *arg1 = (QuantLib::Chile *) 0 ;
  
  arg1 = (QuantLib::Chile *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_France__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::France::Market arg1 ;
  QuantLib::France *result = 0 ;
  
  arg1 = (QuantLib::France::Market)jarg1; 
  {
    try {
      result = (QuantLib::France *)new QuantLib::France(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_France(void * jarg1) {
  QuantLib::France *arg1 = (QuantLib::France *) 0 ;
  
  arg1 = (QuantLib::France *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_Romania__SWIG_0(int jarg1) {
  void * jresult ;
  QuantLib::Romania::Market arg1 ;
  QuantLib::Romania *result = 0 ;
  
  arg1 = (QuantLib::Romania::Market)jarg1; 
  {
    try {
      result = (QuantLib::Romania *)new QuantLib::Romania(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Romania__SWIG_1() {
  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_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_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_Thailand() {
  void * jresult ;
  QuantLib::Thailand *result = 0 ;
  
  {
    try {
      result = (QuantLib::Thailand *)new QuantLib::Thailand();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Thailand(void * jarg1) {
  QuantLib::Thailand *arg1 = (QuantLib::Thailand *) 0 ;
  
  arg1 = (QuantLib::Thailand *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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(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_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 & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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_new_JointCalendar__SWIG_6(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< Calendar > *arg1 = 0 ;
  JointCalendarRule arg2 ;
  QuantLib::JointCalendar *result = 0 ;
  
  arg1 = (std::vector< Calendar > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Calendar > const & is null", 0);
    return 0;
  } 
  arg2 = (JointCalendarRule)jarg2; 
  {
    try {
      result = (QuantLib::JointCalendar *)new QuantLib::JointCalendar((std::vector< Calendar > 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_JointCalendar__SWIG_7(void * jarg1) {
  void * jresult ;
  std::vector< Calendar > *arg1 = 0 ;
  QuantLib::JointCalendar *result = 0 ;
  
  arg1 = (std::vector< Calendar > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Calendar > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (QuantLib::JointCalendar *)new QuantLib::JointCalendar((std::vector< Calendar > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(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(const 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 const char * SWIGSTDCALL CSharp_QuantLib_DayCounter_name(void * jarg1) {
  const 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 const char * SWIGSTDCALL CSharp_QuantLib_DayCounter___str__(void * jarg1) {
  const 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__SWIG_0(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  QuantLib::Actual360 *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (QuantLib::Actual360 *)new QuantLib::Actual360(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Actual360__SWIG_1() {
  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_Actual366__SWIG_0(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  QuantLib::Actual366 *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (QuantLib::Actual366 *)new QuantLib::Actual366(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Actual36525__SWIG_0(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  QuantLib::Actual36525 *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (QuantLib::Actual36525 *)new QuantLib::Actual36525(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


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


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Actual364(void * jarg1) {
  QuantLib::Actual364 *arg1 = (QuantLib::Actual364 *) 0 ;
  
  arg1 = (QuantLib::Actual364 *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 * jarg2) {
  void * jresult ;
  QuantLib::Thirty360::Convention arg1 ;
  Date *arg2 = 0 ;
  QuantLib::Thirty360 *result = 0 ;
  
  arg1 = (QuantLib::Thirty360::Convention)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (QuantLib::Thirty360 *)new QuantLib::Thirty360(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_Thirty360__SWIG_1(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_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_Thirty365() {
  void * jresult ;
  QuantLib::Thirty365 *result = 0 ;
  
  {
    try {
      result = (QuantLib::Thirty365 *)new QuantLib::Thirty365();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Thirty365(void * jarg1) {
  QuantLib::Thirty365 *arg1 = (QuantLib::Thirty365 *) 0 ;
  
  arg1 = (QuantLib::Thirty365 *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & 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_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_yearFractionToDate(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  DayCounter *arg1 = 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  Date result;
  
  arg1 = (DayCounter *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      result = yearFractionToDate((DayCounter 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 = new Date(result); 
  return jresult;
}


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 void * SWIGSTDCALL CSharp_QuantLib_new_Currency__SWIG_0() {
  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_new_Currency__SWIG_1(const char * jarg1, const char * jarg2, int jarg3, const char * jarg4, const char * jarg5, int jarg6, void * jarg7, const char * jarg8, void * jarg9) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Integer arg3 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  Integer arg6 ;
  Rounding *arg7 = 0 ;
  std::string *arg8 = 0 ;
  Currency *arg9 = 0 ;
  Currency *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; 
  arg3 = (Integer)jarg3; 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg4_str(jarg4);
  arg4 = &arg4_str; 
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  arg6 = (Integer)jarg6; 
  arg7 = (Rounding *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Rounding const & is null", 0);
    return 0;
  } 
  if (!jarg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg8_str(jarg8);
  arg8 = &arg8_str; 
  arg9 = (Currency *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Currency *)new Currency((std::string const &)*arg1,(std::string const &)*arg2,arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,(Rounding const &)*arg7,(std::string const &)*arg8,(Currency 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_Currency__SWIG_2(const char * jarg1, const char * jarg2, int jarg3, const char * jarg4, const char * jarg5, int jarg6, void * jarg7, const char * jarg8) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Integer arg3 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  Integer arg6 ;
  Rounding *arg7 = 0 ;
  std::string *arg8 = 0 ;
  Currency *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; 
  arg3 = (Integer)jarg3; 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg4_str(jarg4);
  arg4 = &arg4_str; 
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  arg6 = (Integer)jarg6; 
  arg7 = (Rounding *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Rounding const & is null", 0);
    return 0;
  } 
  if (!jarg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg8_str(jarg8);
  arg8 = &arg8_str; 
  {
    try {
      result = (Currency *)new Currency((std::string const &)*arg1,(std::string const &)*arg2,arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,(Rounding const &)*arg7,(std::string 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 const char * SWIGSTDCALL CSharp_QuantLib_Currency_name(void * jarg1) {
  const 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 const char * SWIGSTDCALL CSharp_QuantLib_Currency_code(void * jarg1) {
  const 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 const char * SWIGSTDCALL CSharp_QuantLib_Currency_symbol(void * jarg1) {
  const 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 const char * SWIGSTDCALL CSharp_QuantLib_Currency_fractionSymbol(void * jarg1) {
  const 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 const char * SWIGSTDCALL CSharp_QuantLib_Currency_format(void * jarg1) {
  const 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 const char * SWIGSTDCALL CSharp_QuantLib_Currency___str__(void * jarg1) {
  const 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_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_AEDCurrency() {
  void * jresult ;
  QuantLib::AEDCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::AEDCurrency *)new QuantLib::AEDCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AOACurrency(void * jarg1) {
  QuantLib::AOACurrency *arg1 = (QuantLib::AOACurrency *) 0 ;
  
  arg1 = (QuantLib::AOACurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_BHDCurrency() {
  void * jresult ;
  QuantLib::BHDCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::BHDCurrency *)new QuantLib::BHDCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BHDCurrency(void * jarg1) {
  QuantLib::BHDCurrency *arg1 = (QuantLib::BHDCurrency *) 0 ;
  
  arg1 = (QuantLib::BHDCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_BGNCurrency() {
  void * jresult ;
  QuantLib::BGNCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::BGNCurrency *)new QuantLib::BGNCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BGNCurrency(void * jarg1) {
  QuantLib::BGNCurrency *arg1 = (QuantLib::BGNCurrency *) 0 ;
  
  arg1 = (QuantLib::BGNCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_BWPCurrency() {
  void * jresult ;
  QuantLib::BWPCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::BWPCurrency *)new QuantLib::BWPCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BWPCurrency(void * jarg1) {
  QuantLib::BWPCurrency *arg1 = (QuantLib::BWPCurrency *) 0 ;
  
  arg1 = (QuantLib::BWPCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_CLFCurrency() {
  void * jresult ;
  QuantLib::CLFCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::CLFCurrency *)new QuantLib::CLFCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CLFCurrency(void * jarg1) {
  QuantLib::CLFCurrency *arg1 = (QuantLib::CLFCurrency *) 0 ;
  
  arg1 = (QuantLib::CLFCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_CNHCurrency() {
  void * jresult ;
  QuantLib::CNHCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::CNHCurrency *)new QuantLib::CNHCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CNHCurrency(void * jarg1) {
  QuantLib::CNHCurrency *arg1 = (QuantLib::CNHCurrency *) 0 ;
  
  arg1 = (QuantLib::CNHCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_COUCurrency() {
  void * jresult ;
  QuantLib::COUCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::COUCurrency *)new QuantLib::COUCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_COUCurrency(void * jarg1) {
  QuantLib::COUCurrency *arg1 = (QuantLib::COUCurrency *) 0 ;
  
  arg1 = (QuantLib::COUCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_EGPCurrency() {
  void * jresult ;
  QuantLib::EGPCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::EGPCurrency *)new QuantLib::EGPCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EGPCurrency(void * jarg1) {
  QuantLib::EGPCurrency *arg1 = (QuantLib::EGPCurrency *) 0 ;
  
  arg1 = (QuantLib::EGPCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_ETBCurrency() {
  void * jresult ;
  QuantLib::ETBCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::ETBCurrency *)new QuantLib::ETBCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ETBCurrency(void * jarg1) {
  QuantLib::ETBCurrency *arg1 = (QuantLib::ETBCurrency *) 0 ;
  
  arg1 = (QuantLib::ETBCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_GELCurrency() {
  void * jresult ;
  QuantLib::GELCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::GELCurrency *)new QuantLib::GELCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GELCurrency(void * jarg1) {
  QuantLib::GELCurrency *arg1 = (QuantLib::GELCurrency *) 0 ;
  
  arg1 = (QuantLib::GELCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_GHSCurrency() {
  void * jresult ;
  QuantLib::GHSCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::GHSCurrency *)new QuantLib::GHSCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GHSCurrency(void * jarg1) {
  QuantLib::GHSCurrency *arg1 = (QuantLib::GHSCurrency *) 0 ;
  
  arg1 = (QuantLib::GHSCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_HRKCurrency() {
  void * jresult ;
  QuantLib::HRKCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::HRKCurrency *)new QuantLib::HRKCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HRKCurrency(void * jarg1) {
  QuantLib::HRKCurrency *arg1 = (QuantLib::HRKCurrency *) 0 ;
  
  arg1 = (QuantLib::HRKCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_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_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_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_JODCurrency() {
  void * jresult ;
  QuantLib::JODCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::JODCurrency *)new QuantLib::JODCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_JODCurrency(void * jarg1) {
  QuantLib::JODCurrency *arg1 = (QuantLib::JODCurrency *) 0 ;
  
  arg1 = (QuantLib::JODCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_KESCurrency() {
  void * jresult ;
  QuantLib::KESCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::KESCurrency *)new QuantLib::KESCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_KESCurrency(void * jarg1) {
  QuantLib::KESCurrency *arg1 = (QuantLib::KESCurrency *) 0 ;
  
  arg1 = (QuantLib::KESCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_KZTCurrency() {
  void * jresult ;
  QuantLib::KZTCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::KZTCurrency *)new QuantLib::KZTCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LKRCurrency(void * jarg1) {
  QuantLib::LKRCurrency *arg1 = (QuantLib::LKRCurrency *) 0 ;
  
  arg1 = (QuantLib::LKRCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_MADCurrency() {
  void * jresult ;
  QuantLib::MADCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::MADCurrency *)new QuantLib::MADCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MADCurrency(void * jarg1) {
  QuantLib::MADCurrency *arg1 = (QuantLib::MADCurrency *) 0 ;
  
  arg1 = (QuantLib::MADCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_MURCurrency() {
  void * jresult ;
  QuantLib::MURCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::MURCurrency *)new QuantLib::MURCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MURCurrency(void * jarg1) {
  QuantLib::MURCurrency *arg1 = (QuantLib::MURCurrency *) 0 ;
  
  arg1 = (QuantLib::MURCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_MXVCurrency() {
  void * jresult ;
  QuantLib::MXVCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::MXVCurrency *)new QuantLib::MXVCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MXVCurrency(void * jarg1) {
  QuantLib::MXVCurrency *arg1 = (QuantLib::MXVCurrency *) 0 ;
  
  arg1 = (QuantLib::MXVCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_NGNCurrency() {
  void * jresult ;
  QuantLib::NGNCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::NGNCurrency *)new QuantLib::NGNCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NGNCurrency(void * jarg1) {
  QuantLib::NGNCurrency *arg1 = (QuantLib::NGNCurrency *) 0 ;
  
  arg1 = (QuantLib::NGNCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_OMRCurrency() {
  void * jresult ;
  QuantLib::OMRCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::OMRCurrency *)new QuantLib::OMRCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_OMRCurrency(void * jarg1) {
  QuantLib::OMRCurrency *arg1 = (QuantLib::OMRCurrency *) 0 ;
  
  arg1 = (QuantLib::OMRCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_PHPCurrency() {
  void * jresult ;
  QuantLib::PHPCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::PHPCurrency *)new QuantLib::PHPCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PHPCurrency(void * jarg1) {
  QuantLib::PHPCurrency *arg1 = (QuantLib::PHPCurrency *) 0 ;
  
  arg1 = (QuantLib::PHPCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_QARCurrency() {
  void * jresult ;
  QuantLib::QARCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::QARCurrency *)new QuantLib::QARCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QARCurrency(void * jarg1) {
  QuantLib::QARCurrency *arg1 = (QuantLib::QARCurrency *) 0 ;
  
  arg1 = (QuantLib::QARCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_RSDCurrency() {
  void * jresult ;
  QuantLib::RSDCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::RSDCurrency *)new QuantLib::RSDCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RSDCurrency(void * jarg1) {
  QuantLib::RSDCurrency *arg1 = (QuantLib::RSDCurrency *) 0 ;
  
  arg1 = (QuantLib::RSDCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_TNDCurrency() {
  void * jresult ;
  QuantLib::TNDCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::TNDCurrency *)new QuantLib::TNDCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TNDCurrency(void * jarg1) {
  QuantLib::TNDCurrency *arg1 = (QuantLib::TNDCurrency *) 0 ;
  
  arg1 = (QuantLib::TNDCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_UAHCurrency() {
  void * jresult ;
  QuantLib::UAHCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::UAHCurrency *)new QuantLib::UAHCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UGXCurrency(void * jarg1) {
  QuantLib::UGXCurrency *arg1 = (QuantLib::UGXCurrency *) 0 ;
  
  arg1 = (QuantLib::UGXCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_UYUCurrency() {
  void * jresult ;
  QuantLib::UYUCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::UYUCurrency *)new QuantLib::UYUCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UYUCurrency(void * jarg1) {
  QuantLib::UYUCurrency *arg1 = (QuantLib::UYUCurrency *) 0 ;
  
  arg1 = (QuantLib::UYUCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_XOFCurrency() {
  void * jresult ;
  QuantLib::XOFCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::XOFCurrency *)new QuantLib::XOFCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_XOFCurrency(void * jarg1) {
  QuantLib::XOFCurrency *arg1 = (QuantLib::XOFCurrency *) 0 ;
  
  arg1 = (QuantLib::XOFCurrency *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_ZMWCurrency() {
  void * jresult ;
  QuantLib::ZMWCurrency *result = 0 ;
  
  {
    try {
      result = (QuantLib::ZMWCurrency *)new QuantLib::ZMWCurrency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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 & 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(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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & 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(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 & is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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(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 & is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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(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 & is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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(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(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 & is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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(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 & is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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(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 & is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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(result); 
  return jresult;
}


SWIGEXPORT const char * SWIGSTDCALL CSharp_QuantLib_InterestRate___str__(void * jarg1) {
  const 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 & 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 & 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(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 ;
  std::vector< InterestRate >::value_type *result = 0 ;
  
  arg1 = (std::vector< InterestRate > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< InterestRate >::value_type *) &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 & 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 & 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 & 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 & 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 & 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 & 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_Observable() {
  void * jresult ;
  Observable *result = 0 ;
  
  {
    try {
      result = (Observable *)new 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 = result ? new ext::shared_ptr<  Observable >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Observable(void * jarg1) {
  Observable *arg1 = (Observable *) 0 ;
  ext::shared_ptr< Observable > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Observable > *)jarg1;
  arg1 = (Observable *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & 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 const char * SWIGSTDCALL CSharp_QuantLib_QlArray___str__(void * jarg1) {
  const 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,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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,SWIG_STD_MOVE(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 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 & 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 const char * SWIGSTDCALL CSharp_QuantLib_Matrix___str__(void * jarg1) {
  const 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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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_inverse(void * jarg1) {
  void * jresult ;
  Matrix *arg1 = 0 ;
  Matrix result;
  
  arg1 = (Matrix *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  {
    try {
      result = inverse((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(result); 
  return jresult;
}


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 & 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(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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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(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 & 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(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 & 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(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_delete_MatrixMultiplicationDelegate(void * jarg1) {
  MatrixMultiplicationDelegate *arg1 = (MatrixMultiplicationDelegate *) 0 ;
  
  arg1 = (MatrixMultiplicationDelegate *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MatrixMultiplicationDelegate_apply(void * jarg1, void * jarg2) {
  void * jresult ;
  MatrixMultiplicationDelegate *arg1 = (MatrixMultiplicationDelegate *) 0 ;
  Array *arg2 = 0 ;
  Array result;
  
  arg1 = (MatrixMultiplicationDelegate *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((MatrixMultiplicationDelegate const *)arg1)->apply((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(result); 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BiCGstab_solve__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  BiCGstab *arg1 = (BiCGstab *) 0 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  ext::shared_ptr< BiCGstab const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const BiCGstab > *)jarg1;
  arg1 = (BiCGstab *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = BiCGstab_solve__SWIG_0((BiCGstab 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 = new Array(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BiCGstab_solve__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  BiCGstab *arg1 = (BiCGstab *) 0 ;
  Array *arg2 = 0 ;
  ext::shared_ptr< BiCGstab const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const BiCGstab > *)jarg1;
  arg1 = (BiCGstab *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = BiCGstab_solve__SWIG_0((BiCGstab 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 Array(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BiCGstab__SWIG_0(void * jarg1, unsigned long jarg2, double jarg3) {
  void * jresult ;
  MatrixMultiplicationDelegate *arg1 = (MatrixMultiplicationDelegate *) 0 ;
  Size arg2 ;
  Real arg3 ;
  BiCGstab *result = 0 ;
  
  arg1 = (MatrixMultiplicationDelegate *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (BiCGstab *)new_BiCGstab__SWIG_0(arg1,SWIG_STD_MOVE(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 ? new ext::shared_ptr<  BiCGstab >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BiCGstab__SWIG_1(void * jarg1, unsigned long jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  MatrixMultiplicationDelegate *arg1 = (MatrixMultiplicationDelegate *) 0 ;
  Size arg2 ;
  Real arg3 ;
  MatrixMultiplicationDelegate *arg4 = (MatrixMultiplicationDelegate *) 0 ;
  BiCGstab *result = 0 ;
  
  arg1 = (MatrixMultiplicationDelegate *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (MatrixMultiplicationDelegate *)jarg4; 
  {
    try {
      result = (BiCGstab *)new_BiCGstab__SWIG_1(arg1,SWIG_STD_MOVE(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 ? new ext::shared_ptr<  BiCGstab >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BiCGstab(void * jarg1) {
  BiCGstab *arg1 = (BiCGstab *) 0 ;
  ext::shared_ptr< BiCGstab > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BiCGstab > *)jarg1;
  arg1 = (BiCGstab *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GMRES_solve__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  GMRES *arg1 = (GMRES *) 0 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  ext::shared_ptr< GMRES const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const GMRES > *)jarg1;
  arg1 = (GMRES *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = GMRES_solve__SWIG_0((GMRES 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 = new Array(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GMRES_solve__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  GMRES *arg1 = (GMRES *) 0 ;
  Array *arg2 = 0 ;
  ext::shared_ptr< GMRES const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const GMRES > *)jarg1;
  arg1 = (GMRES *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = GMRES_solve__SWIG_0((GMRES 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 Array(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GMRES_solveWithRestart__SWIG_0(void * jarg1, unsigned long jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  GMRES *arg1 = (GMRES *) 0 ;
  Size arg2 ;
  Array *arg3 = 0 ;
  Array *arg4 = 0 ;
  ext::shared_ptr< GMRES const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const GMRES > *)jarg1;
  arg1 = (GMRES *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg4 = (Array *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = GMRES_solveWithRestart__SWIG_0((GMRES const *)arg1,SWIG_STD_MOVE(arg2),(Array const &)*arg3,(Array 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 Array(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GMRES_solveWithRestart__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  GMRES *arg1 = (GMRES *) 0 ;
  Size arg2 ;
  Array *arg3 = 0 ;
  ext::shared_ptr< GMRES const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const GMRES > *)jarg1;
  arg1 = (GMRES *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = GMRES_solveWithRestart__SWIG_0((GMRES const *)arg1,SWIG_STD_MOVE(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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GMRES__SWIG_0(void * jarg1, unsigned long jarg2, double jarg3) {
  void * jresult ;
  MatrixMultiplicationDelegate *arg1 = (MatrixMultiplicationDelegate *) 0 ;
  Size arg2 ;
  Real arg3 ;
  GMRES *result = 0 ;
  
  arg1 = (MatrixMultiplicationDelegate *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (GMRES *)new_GMRES__SWIG_0(arg1,SWIG_STD_MOVE(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 ? new ext::shared_ptr<  GMRES >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GMRES__SWIG_1(void * jarg1, unsigned long jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  MatrixMultiplicationDelegate *arg1 = (MatrixMultiplicationDelegate *) 0 ;
  Size arg2 ;
  Real arg3 ;
  MatrixMultiplicationProxy *arg4 = 0 ;
  GMRES *result = 0 ;
  
  arg1 = (MatrixMultiplicationDelegate *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (MatrixMultiplicationProxy *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MatrixMultiplicationProxy const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (GMRES *)new_GMRES__SWIG_1(arg1,SWIG_STD_MOVE(arg2),arg3,(MatrixMultiplicationProxy 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 ? new ext::shared_ptr<  GMRES >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GMRES(void * jarg1) {
  GMRES *arg1 = (GMRES *) 0 ;
  ext::shared_ptr< GMRES > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GMRES > *)jarg1;
  arg1 = (GMRES *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_close__SWIG_0(double jarg1, double jarg2) {
  unsigned int jresult ;
  Real arg1 ;
  Real arg2 ;
  bool result;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (bool)close(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_close__SWIG_1(double jarg1, double jarg2, unsigned long jarg3) {
  unsigned int jresult ;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  bool result;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (bool)close(arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_close_enough__SWIG_0(double jarg1, double jarg2) {
  unsigned int jresult ;
  Real arg1 ;
  Real arg2 ;
  bool result;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (bool)close_enough(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_close_enough__SWIG_1(double jarg1, double jarg2, unsigned long jarg3) {
  unsigned int jresult ;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  bool result;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (bool)close_enough(arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_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 = static_cast<SwigDirector_UnaryFunctionDelegate *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinaryFunction(void * jarg1) {
  void * jresult ;
  BinaryFunctionDelegate *arg1 = (BinaryFunctionDelegate *) 0 ;
  BinaryFunction *result = 0 ;
  
  arg1 = (BinaryFunctionDelegate *)jarg1; 
  {
    try {
      result = (BinaryFunction *)new BinaryFunction(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_BinaryFunction_call(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  BinaryFunction *arg1 = (BinaryFunction *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real result;
  
  arg1 = (BinaryFunction *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((BinaryFunction const *)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_BinaryFunction(void * jarg1) {
  BinaryFunction *arg1 = (BinaryFunction *) 0 ;
  
  arg1 = (BinaryFunction *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_BinaryFunctionDelegate(void * jarg1) {
  BinaryFunctionDelegate *arg1 = (BinaryFunctionDelegate *) 0 ;
  
  arg1 = (BinaryFunctionDelegate *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_BinaryFunctionDelegate_value(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  BinaryFunctionDelegate *arg1 = (BinaryFunctionDelegate *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real result;
  
  arg1 = (BinaryFunctionDelegate *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((BinaryFunctionDelegate const *)arg1)->value(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_BinaryFunctionDelegate_valueSwigExplicitBinaryFunctionDelegate(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  BinaryFunctionDelegate *arg1 = (BinaryFunctionDelegate *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real result;
  
  arg1 = (BinaryFunctionDelegate *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((BinaryFunctionDelegate const *)arg1)->BinaryFunctionDelegate::value(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_new_BinaryFunctionDelegate() {
  void * jresult ;
  BinaryFunctionDelegate *result = 0 ;
  
  {
    try {
      result = (BinaryFunctionDelegate *)new SwigDirector_BinaryFunctionDelegate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BinaryFunctionDelegate_director_connect(void *objarg, SwigDirector_BinaryFunctionDelegate::SWIG_Callback0_t callback0) {
  BinaryFunctionDelegate *obj = (BinaryFunctionDelegate *)objarg;
  SwigDirector_BinaryFunctionDelegate *director = static_cast<SwigDirector_BinaryFunctionDelegate *>(obj);
  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 & 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 ;
  Array result;
  
  arg1 = (DotNetCostFunction *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 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 & 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 & 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 & 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(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 & 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(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 = static_cast<SwigDirector_CostFunctionDelegate *>(obj);
  director->swig_connect_director(callback0, callback1);
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Quote_value(void * jarg1) {
  double jresult ;
  Quote *arg1 = (Quote *) 0 ;
  ext::shared_ptr< Quote const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Quote > *)jarg1;
  arg1 = (Quote *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((Quote 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 unsigned int SWIGSTDCALL CSharp_QuantLib_Quote_isValid(void * jarg1) {
  unsigned int jresult ;
  Quote *arg1 = (Quote *) 0 ;
  ext::shared_ptr< Quote const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const Quote > *)jarg1;
  arg1 = (Quote *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((Quote const *)arg1)->isValid();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_Quote(void * jarg1) {
  Quote *arg1 = (Quote *) 0 ;
  ext::shared_ptr< Quote > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Quote > *)jarg1;
  arg1 = (Quote *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuoteHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< Quote > *arg1 = 0 ;
  ext::shared_ptr< Quote > tempnull1 ;
  Handle< Quote > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Quote > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Handle< Quote > *)new Handle< Quote >((ext::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 ;
  ext::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 = result ? new ext::shared_ptr< Quote >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteHandle_currentLink(void * jarg1) {
  void * jresult ;
  Handle< Quote > *arg1 = (Handle< Quote > *) 0 ;
  ext::shared_ptr< Quote > result;
  
  arg1 = (Handle< Quote > *)jarg1; 
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< Quote >(result) : 0; 
  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 ;
  ext::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 = result ? new ext::shared_ptr< Observable >(result) : 0; 
  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 unsigned int SWIGSTDCALL CSharp_QuantLib_QuoteHandle_isValid(void * jarg1) {
  unsigned int jresult ;
  Handle< Quote > *arg1 = (Handle< Quote > *) 0 ;
  bool result;
  
  arg1 = (Handle< Quote > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->isValid();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  ext::shared_ptr< Quote > *arg1 = 0 ;
  ext::shared_ptr< Quote > tempnull1 ;
  RelinkableHandle< Quote > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Quote > *)jarg1 : &tempnull1; 
  {
    try {
      result = (RelinkableHandle< Quote > *)new RelinkableHandle< Quote >((ext::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 ;
  ext::shared_ptr< Quote > *arg2 = 0 ;
  ext::shared_ptr< Quote > tempnull2 ;
  
  arg1 = (RelinkableHandle< Quote > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Quote > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->linkTo((ext::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_RelinkableQuoteHandle_reset(void * jarg1) {
  RelinkableHandle< Quote > *arg1 = (RelinkableHandle< Quote > *) 0 ;
  
  arg1 = (RelinkableHandle< Quote > *)jarg1; 
  {
    try {
      RelinkableHandle_Sl_Quote_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  SimpleQuote *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (SimpleQuote *)new SimpleQuote(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  SimpleQuote >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SimpleQuote_setValue(void * jarg1, double jarg2) {
  SimpleQuote *arg1 = (SimpleQuote *) 0 ;
  Real arg2 ;
  ext::shared_ptr< SimpleQuote > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SimpleQuote > *)jarg1;
  arg1 = (SimpleQuote *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  {
    try {
      (arg1)->setValue(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) {
  SimpleQuote *arg1 = (SimpleQuote *) 0 ;
  ext::shared_ptr< SimpleQuote > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SimpleQuote > *)jarg1;
  arg1 = (SimpleQuote *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LastFixingQuote(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< Index > arg1 ;
  ext::shared_ptr< Index > *argp1 ;
  LastFixingQuote *result = 0 ;
  
  argp1 = (ext::shared_ptr< Index > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::shared_ptr< Index >", 0);
    return 0;
  }
  arg1 = *argp1; 
  {
    try {
      result = (LastFixingQuote *)new LastFixingQuote(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  LastFixingQuote >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LastFixingQuote_index(void * jarg1) {
  void * jresult ;
  LastFixingQuote *arg1 = (LastFixingQuote *) 0 ;
  ext::shared_ptr< LastFixingQuote const > *smartarg1 = 0 ;
  ext::shared_ptr< Index > result;
  
  
  smartarg1 = (ext::shared_ptr< const LastFixingQuote > *)jarg1;
  arg1 = (LastFixingQuote *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((LastFixingQuote const *)arg1)->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 = new ext::shared_ptr< Index >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LastFixingQuote_referenceDate(void * jarg1) {
  void * jresult ;
  LastFixingQuote *arg1 = (LastFixingQuote *) 0 ;
  ext::shared_ptr< LastFixingQuote const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const LastFixingQuote > *)jarg1;
  arg1 = (LastFixingQuote *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((LastFixingQuote const *)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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LastFixingQuote(void * jarg1) {
  LastFixingQuote *arg1 = (LastFixingQuote *) 0 ;
  ext::shared_ptr< LastFixingQuote > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  LastFixingQuote > *)jarg1;
  arg1 = (LastFixingQuote *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  
  arg1 = (std::vector< ext::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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  ext::shared_ptr< Quote > *arg2 = 0 ;
  ext::shared_ptr< Quote > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Quote > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = (std::vector< ext::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< ext::shared_ptr< Quote > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< Quote > > *)new std::vector< ext::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< ext::shared_ptr< Quote > > *arg1 = 0 ;
  std::vector< ext::shared_ptr< Quote > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< ext::shared_ptr< Quote > > *)new std::vector< ext::shared_ptr< Quote > >((std::vector< ext::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< ext::shared_ptr< Quote > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Quote > > *)new_std_vector_Sl_ext_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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< Quote > result;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_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 = result ? new ext::shared_ptr< Quote >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Quote > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Quote > >::value_type *) &std_vector_Sl_ext_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 = *result ? new std::vector< ext::shared_ptr< Quote > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_QuoteVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< Quote > *arg3 = 0 ;
  ext::shared_ptr< Quote > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< Quote > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__setitem(arg1,arg2,(ext::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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Quote > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__AddRange(arg1,(std::vector< ext::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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< Quote > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Quote > > *)std_vector_Sl_ext_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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< Quote > *arg3 = 0 ;
  ext::shared_ptr< Quote > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< Quote > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Insert(arg1,arg2,(ext::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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Quote > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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 ;
  ext::shared_ptr< Quote > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< Quote > tempnull1 ;
  std::vector< ext::shared_ptr< Quote > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Quote > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Quote > > *)std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Repeat((ext::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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Quote > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  ext::shared_ptr< Quote > *arg2 = 0 ;
  ext::shared_ptr< Quote > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Quote > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Contains(arg1,(ext::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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  ext::shared_ptr< Quote > *arg2 = 0 ;
  ext::shared_ptr< Quote > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Quote > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__IndexOf(arg1,(ext::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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  ext::shared_ptr< Quote > *arg2 = 0 ;
  ext::shared_ptr< Quote > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Quote > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__LastIndexOf(arg1,(ext::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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  ext::shared_ptr< Quote > *arg2 = 0 ;
  ext::shared_ptr< Quote > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Quote > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Remove(arg1,(ext::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< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  
  arg1 = (std::vector< ext::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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  
  arg1 = (std::vector< std::vector< ext::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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Quote > > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< ext::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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type result;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1; 
  {
    try {
      result = ((std::vector< std::vector< ext::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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type result;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1; 
  {
    try {
      result = ((std::vector< std::vector< ext::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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type arg2 ;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (std::vector< std::vector< ext::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< ext::shared_ptr< Quote > > > *result = 0 ;
  
  {
    try {
      result = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)new std::vector< std::vector< ext::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< ext::shared_ptr< Quote > > > *arg1 = 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< ext::shared_ptr< Quote > > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)new std::vector< std::vector< ext::shared_ptr< Quote > > >((std::vector< std::vector< ext::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< ext::shared_ptr< Quote > > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)new_std_vector_Sl_std_vector_Sl_ext_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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Quote > > result;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_ext_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< ext::shared_ptr< Quote > >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_QuoteVectorVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type *result = 0 ;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type *) &std_vector_Sl_std_vector_Sl_ext_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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Quote > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__setitem(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< ext::shared_ptr< Quote > > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__AddRange(arg1,(std::vector< std::vector< ext::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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)std_vector_Sl_std_vector_Sl_ext_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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Quote > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__Insert(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< ext::shared_ptr< Quote > > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< ext::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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_ext_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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_ext_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< ext::shared_ptr< Quote > > *arg1 = 0 ;
  int arg2 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Quote > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Quote > > const & is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__Repeat((std::vector< ext::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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1; 
  {
    try {
      std_vector_Sl_std_vector_Sl_ext_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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_ext_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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< ext::shared_ptr< Quote > > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< ext::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< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  
  arg1 = (std::vector< std::vector< ext::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 & 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 & 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 >(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 ;
  std::vector< Handle< Quote > >::value_type *result = 0 ;
  
  arg1 = (std::vector< Handle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< Handle< Quote > >::value_type *) &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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 > >(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< std::vector< Handle< Quote > > >::value_type *result = 0 ;
  
  arg1 = (std::vector< std::vector< Handle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::vector< Handle< Quote > > >::value_type *) &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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 >(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 ;
  std::vector< RelinkableHandle< Quote > >::value_type *result = 0 ;
  
  arg1 = (std::vector< RelinkableHandle< Quote > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< RelinkableHandle< Quote > >::value_type *) &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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 & 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 > >(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< std::vector< RelinkableHandle< Quote > > >::value_type *result = 0 ;
  
  arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::vector< RelinkableHandle< Quote > > >::value_type *) &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 & 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 & 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 & 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 & 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 & 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 & 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 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_Newton_setMaxEvaluations(void * jarg1, unsigned long jarg2) {
  Newton *arg1 = (Newton *) 0 ;
  Size arg2 ;
  
  arg1 = (Newton *)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_Newton_setLowerBound(void * jarg1, double jarg2) {
  Newton *arg1 = (Newton *) 0 ;
  Real arg2 ;
  
  arg1 = (Newton *)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_Newton_setUpperBound(void * jarg1, double jarg2) {
  Newton *arg1 = (Newton *) 0 ;
  Real arg2 ;
  
  arg1 = (Newton *)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_Newton_solve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5, double jarg6) {
  double jresult ;
  Newton *arg1 = (Newton *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  UnaryFunctionDelegate *arg3 = (UnaryFunctionDelegate *) 0 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real result;
  
  arg1 = (Newton *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (UnaryFunctionDelegate *)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (Real)Newton_solve__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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Newton_solve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5, double jarg6, double jarg7) {
  double jresult ;
  Newton *arg1 = (Newton *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  UnaryFunctionDelegate *arg3 = (UnaryFunctionDelegate *) 0 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real result;
  
  arg1 = (Newton *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (UnaryFunctionDelegate *)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (Real)Newton_solve__SWIG_1(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 void * SWIGSTDCALL CSharp_QuantLib_new_Newton() {
  void * jresult ;
  Newton *result = 0 ;
  
  {
    try {
      result = (Newton *)new Newton();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_NewtonSafe_setMaxEvaluations(void * jarg1, unsigned long jarg2) {
  NewtonSafe *arg1 = (NewtonSafe *) 0 ;
  Size arg2 ;
  
  arg1 = (NewtonSafe *)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_NewtonSafe_setLowerBound(void * jarg1, double jarg2) {
  NewtonSafe *arg1 = (NewtonSafe *) 0 ;
  Real arg2 ;
  
  arg1 = (NewtonSafe *)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_NewtonSafe_setUpperBound(void * jarg1, double jarg2) {
  NewtonSafe *arg1 = (NewtonSafe *) 0 ;
  Real arg2 ;
  
  arg1 = (NewtonSafe *)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_NewtonSafe_solve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5, double jarg6) {
  double jresult ;
  NewtonSafe *arg1 = (NewtonSafe *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  UnaryFunctionDelegate *arg3 = (UnaryFunctionDelegate *) 0 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real result;
  
  arg1 = (NewtonSafe *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (UnaryFunctionDelegate *)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (Real)NewtonSafe_solve__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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_NewtonSafe_solve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5, double jarg6, double jarg7) {
  double jresult ;
  NewtonSafe *arg1 = (NewtonSafe *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  UnaryFunctionDelegate *arg3 = (UnaryFunctionDelegate *) 0 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real result;
  
  arg1 = (NewtonSafe *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (UnaryFunctionDelegate *)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (Real)NewtonSafe_solve__SWIG_1(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 void * SWIGSTDCALL CSharp_QuantLib_new_NewtonSafe() {
  void * jresult ;
  NewtonSafe *result = 0 ;
  
  {
    try {
      result = (NewtonSafe *)new NewtonSafe();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NewtonSafe(void * jarg1) {
  NewtonSafe *arg1 = (NewtonSafe *) 0 ;
  
  arg1 = (NewtonSafe *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  ext::shared_ptr< Constraint > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Constraint > *)jarg1;
  arg1 = (Constraint *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 = result ? new ext::shared_ptr<  BoundaryConstraint >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BoundaryConstraint(void * jarg1) {
  BoundaryConstraint *arg1 = (BoundaryConstraint *) 0 ;
  ext::shared_ptr< BoundaryConstraint > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BoundaryConstraint > *)jarg1;
  arg1 = (BoundaryConstraint *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 = result ? new ext::shared_ptr<  NoConstraint >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NoConstraint(void * jarg1) {
  NoConstraint *arg1 = (NoConstraint *) 0 ;
  ext::shared_ptr< NoConstraint > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  NoConstraint > *)jarg1;
  arg1 = (NoConstraint *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 = result ? new ext::shared_ptr<  PositiveConstraint >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PositiveConstraint(void * jarg1) {
  PositiveConstraint *arg1 = (PositiveConstraint *) 0 ;
  ext::shared_ptr< PositiveConstraint > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PositiveConstraint > *)jarg1;
  arg1 = (PositiveConstraint *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 *)(((ext::shared_ptr< const Constraint > *)jarg1) ? ((ext::shared_ptr< const Constraint > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return 0;
  } 
  
  arg2 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg2) ? ((ext::shared_ptr< const Constraint > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference 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 = result ? new ext::shared_ptr<  CompositeConstraint >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CompositeConstraint(void * jarg1) {
  CompositeConstraint *arg1 = (CompositeConstraint *) 0 ;
  ext::shared_ptr< CompositeConstraint > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CompositeConstraint > *)jarg1;
  arg1 = (CompositeConstraint *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 = result ? new ext::shared_ptr<  NonhomogeneousBoundaryConstraint >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NonhomogeneousBoundaryConstraint(void * jarg1) {
  NonhomogeneousBoundaryConstraint *arg1 = (NonhomogeneousBoundaryConstraint *) 0 ;
  ext::shared_ptr< NonhomogeneousBoundaryConstraint > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  NonhomogeneousBoundaryConstraint > *)jarg1;
  arg1 = (NonhomogeneousBoundaryConstraint *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 = result ? new ext::shared_ptr<  EndCriteria >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< EndCriteria const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const EndCriteria > *)jarg1;
  arg1 = (EndCriteria *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  arg3 = (Size *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Size & 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 & 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 ;
  ext::shared_ptr< EndCriteria > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EndCriteria > *)jarg1;
  arg1 = (EndCriteria *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  ext::shared_ptr< OptimizationMethod > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OptimizationMethod > *)jarg1;
  arg1 = (OptimizationMethod *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 = result ? new ext::shared_ptr<  ConjugateGradient >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ConjugateGradient(void * jarg1) {
  ConjugateGradient *arg1 = (ConjugateGradient *) 0 ;
  ext::shared_ptr< ConjugateGradient > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ConjugateGradient > *)jarg1;
  arg1 = (ConjugateGradient *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 = result ? new ext::shared_ptr<  Simplex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Simplex_lambda(void * jarg1) {
  double jresult ;
  Simplex *arg1 = (Simplex *) 0 ;
  ext::shared_ptr< Simplex > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Simplex > *)jarg1;
  arg1 = (Simplex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->lambda();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_Simplex(void * jarg1) {
  Simplex *arg1 = (Simplex *) 0 ;
  ext::shared_ptr< Simplex > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Simplex > *)jarg1;
  arg1 = (Simplex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 = result ? new ext::shared_ptr<  SteepestDescent >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SteepestDescent(void * jarg1) {
  SteepestDescent *arg1 = (SteepestDescent *) 0 ;
  ext::shared_ptr< SteepestDescent > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SteepestDescent > *)jarg1;
  arg1 = (SteepestDescent *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 = result ? new ext::shared_ptr<  BFGS >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BFGS(void * jarg1) {
  BFGS *arg1 = (BFGS *) 0 ;
  ext::shared_ptr< BFGS > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BFGS > *)jarg1;
  arg1 = (BFGS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, unsigned int jarg4) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  bool arg4 ;
  LevenbergMarquardt *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (LevenbergMarquardt *)new LevenbergMarquardt(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 ? new ext::shared_ptr<  LevenbergMarquardt >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LevenbergMarquardt__SWIG_1(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 = result ? new ext::shared_ptr<  LevenbergMarquardt >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LevenbergMarquardt__SWIG_2(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 = result ? new ext::shared_ptr<  LevenbergMarquardt >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LevenbergMarquardt__SWIG_3(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 = result ? new ext::shared_ptr<  LevenbergMarquardt >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LevenbergMarquardt__SWIG_4() {
  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 = result ? new ext::shared_ptr<  LevenbergMarquardt >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LevenbergMarquardt(void * jarg1) {
  LevenbergMarquardt *arg1 = (LevenbergMarquardt *) 0 ;
  ext::shared_ptr< LevenbergMarquardt > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  LevenbergMarquardt > *)jarg1;
  arg1 = (LevenbergMarquardt *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 = result ? new ext::shared_ptr<  DifferentialEvolution >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DifferentialEvolution(void * jarg1) {
  DifferentialEvolution *arg1 = (DifferentialEvolution *) 0 ;
  ext::shared_ptr< DifferentialEvolution > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DifferentialEvolution > *)jarg1;
  arg1 = (DifferentialEvolution *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  GaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  GaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  GaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  GaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  GaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  GaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & 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 = result ? new ext::shared_ptr<  GaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussianSimulatedAnnealing(void * jarg1) {
  GaussianSimulatedAnnealing *arg1 = (GaussianSimulatedAnnealing *) 0 ;
  ext::shared_ptr< GaussianSimulatedAnnealing > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GaussianSimulatedAnnealing > *)jarg1;
  arg1 = (GaussianSimulatedAnnealing *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  MirrorGaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  MirrorGaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  MirrorGaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  MirrorGaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  MirrorGaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  MirrorGaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & 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 = result ? new ext::shared_ptr<  MirrorGaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MirrorGaussianSimulatedAnnealing(void * jarg1) {
  MirrorGaussianSimulatedAnnealing *arg1 = (MirrorGaussianSimulatedAnnealing *) 0 ;
  ext::shared_ptr< MirrorGaussianSimulatedAnnealing > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MirrorGaussianSimulatedAnnealing > *)jarg1;
  arg1 = (MirrorGaussianSimulatedAnnealing *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  LogNormalSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  LogNormalSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  LogNormalSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  LogNormalSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  LogNormalSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & is null", 0);
    return 0;
  } 
  arg4 = (ReannealingTrivial *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ReannealingTrivial const & 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 = result ? new ext::shared_ptr<  LogNormalSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & is null", 0);
    return 0;
  } 
  arg2 = (ProbabilityBoltzmannDownhill *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ProbabilityBoltzmannDownhill const & is null", 0);
    return 0;
  } 
  arg3 = (TemperatureExponential *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TemperatureExponential const & 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 = result ? new ext::shared_ptr<  LogNormalSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LogNormalSimulatedAnnealing(void * jarg1) {
  LogNormalSimulatedAnnealing *arg1 = (LogNormalSimulatedAnnealing *) 0 ;
  ext::shared_ptr< LogNormalSimulatedAnnealing > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  LogNormalSimulatedAnnealing > *)jarg1;
  arg1 = (LogNormalSimulatedAnnealing *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 *)(((ext::shared_ptr<  Constraint > *)jarg3) ? ((ext::shared_ptr<  Constraint > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint & reference is null", 0);
    return 0;
  } 
  
  arg4 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg4) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return 0;
  } 
  
  arg5 = (EndCriteria *)(((ext::shared_ptr<  EndCriteria > *)jarg5) ? ((ext::shared_ptr<  EndCriteria > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria & reference is null", 0);
    return 0;
  } 
  arg6 = (Array *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & 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(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_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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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_LagrangeInterpolation(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeLagrangeInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeLagrangeInterpolation *)new SafeLagrangeInterpolation((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_LagrangeInterpolation_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeLagrangeInterpolation *arg1 = (SafeLagrangeInterpolation *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeLagrangeInterpolation *)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_LagrangeInterpolation_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeLagrangeInterpolation *arg1 = (SafeLagrangeInterpolation *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeLagrangeInterpolation *)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_LagrangeInterpolation(void * jarg1) {
  SafeLagrangeInterpolation *arg1 = (SafeLagrangeInterpolation *) 0 ;
  
  arg1 = (SafeLagrangeInterpolation *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Matrix *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Matrix *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & 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_delete_CubicInterpolation(void * jarg1) {
  CubicInterpolation *arg1 = (CubicInterpolation *) 0 ;
  
  arg1 = (CubicInterpolation *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_MixedInterpolation(void * jarg1) {
  MixedInterpolation *arg1 = (MixedInterpolation *) 0 ;
  
  arg1 = (MixedInterpolation *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_Bicubic() {
  void * jresult ;
  Bicubic *result = 0 ;
  
  {
    try {
      result = (Bicubic *)new Bicubic();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bicubic(void * jarg1) {
  Bicubic *arg1 = (Bicubic *) 0 ;
  
  arg1 = (Bicubic *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_new_SplineCubic() {
  void * jresult ;
  SplineCubic *result = 0 ;
  
  {
    try {
      result = (SplineCubic *)new SplineCubic();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


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


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


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


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


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


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvexMonotone__SWIG_0(double jarg1, double jarg2, unsigned int jarg3) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  bool arg3 ;
  ConvexMonotone *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (ConvexMonotone *)new ConvexMonotone(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_ConvexMonotone__SWIG_1(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  ConvexMonotone *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (ConvexMonotone *)new ConvexMonotone(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_ConvexMonotone__SWIG_2(double jarg1) {
  void * jresult ;
  Real arg1 ;
  ConvexMonotone *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (ConvexMonotone *)new ConvexMonotone(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogMixedLinearCubic__SWIG_0(unsigned long jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  Size arg1 ;
  MixedInterpolation::Behavior arg2 ;
  CubicInterpolation::DerivativeApprox arg3 ;
  bool arg4 ;
  LogMixedLinearCubic *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (MixedInterpolation::Behavior)jarg2; 
  arg3 = (CubicInterpolation::DerivativeApprox)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (LogMixedLinearCubic *)new LogMixedLinearCubic(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_LogMixedLinearCubic__SWIG_1(unsigned long jarg1, int jarg2, int jarg3) {
  void * jresult ;
  Size arg1 ;
  MixedInterpolation::Behavior arg2 ;
  CubicInterpolation::DerivativeApprox arg3 ;
  LogMixedLinearCubic *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (MixedInterpolation::Behavior)jarg2; 
  arg3 = (CubicInterpolation::DerivativeApprox)jarg3; 
  {
    try {
      result = (LogMixedLinearCubic *)new LogMixedLinearCubic(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_LogMixedLinearCubic__SWIG_2(unsigned long jarg1, int jarg2) {
  void * jresult ;
  Size arg1 ;
  MixedInterpolation::Behavior arg2 ;
  LogMixedLinearCubic *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (MixedInterpolation::Behavior)jarg2; 
  {
    try {
      result = (LogMixedLinearCubic *)new LogMixedLinearCubic(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_LogMixedLinearCubic__SWIG_3(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  LogMixedLinearCubic *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (LogMixedLinearCubic *)new LogMixedLinearCubic(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SABRInterpolation__SWIG_0(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, unsigned int jarg9, unsigned int jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13, void * jarg14, void * jarg15, double jarg16, unsigned int jarg17, unsigned long jarg18, double jarg19) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  ext::shared_ptr< EndCriteria > *arg14 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg15 = 0 ;
  Real arg16 ;
  bool arg17 ;
  Size arg18 ;
  Real arg19 ;
  ext::shared_ptr< EndCriteria > tempnull14 ;
  ext::shared_ptr< OptimizationMethod > tempnull15 ;
  SafeSABRInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = jarg9 ? true : false; 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? (ext::shared_ptr< EndCriteria > *)jarg14 : &tempnull14; 
  arg15 = jarg15 ? (ext::shared_ptr< OptimizationMethod > *)jarg15 : &tempnull15; 
  arg16 = (Real)jarg16; 
  arg17 = jarg17 ? true : false; 
  arg18 = (Size)jarg18; 
  arg19 = (Real)jarg19; 
  {
    try {
      result = (SafeSABRInterpolation *)new SafeSABRInterpolation((Array const &)*arg1,(Array const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(ext::shared_ptr< EndCriteria > const &)*arg14,(ext::shared_ptr< OptimizationMethod > const &)*arg15,arg16,arg17,arg18,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_SABRInterpolation__SWIG_1(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, unsigned int jarg9, unsigned int jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13, void * jarg14, void * jarg15, double jarg16, unsigned int jarg17, unsigned long jarg18) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  ext::shared_ptr< EndCriteria > *arg14 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg15 = 0 ;
  Real arg16 ;
  bool arg17 ;
  Size arg18 ;
  ext::shared_ptr< EndCriteria > tempnull14 ;
  ext::shared_ptr< OptimizationMethod > tempnull15 ;
  SafeSABRInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = jarg9 ? true : false; 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? (ext::shared_ptr< EndCriteria > *)jarg14 : &tempnull14; 
  arg15 = jarg15 ? (ext::shared_ptr< OptimizationMethod > *)jarg15 : &tempnull15; 
  arg16 = (Real)jarg16; 
  arg17 = jarg17 ? true : false; 
  arg18 = (Size)jarg18; 
  {
    try {
      result = (SafeSABRInterpolation *)new SafeSABRInterpolation((Array const &)*arg1,(Array const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(ext::shared_ptr< EndCriteria > const &)*arg14,(ext::shared_ptr< OptimizationMethod > const &)*arg15,arg16,arg17,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_SABRInterpolation__SWIG_2(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, unsigned int jarg9, unsigned int jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13, void * jarg14, void * jarg15, double jarg16, unsigned int jarg17) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  ext::shared_ptr< EndCriteria > *arg14 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg15 = 0 ;
  Real arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > tempnull14 ;
  ext::shared_ptr< OptimizationMethod > tempnull15 ;
  SafeSABRInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = jarg9 ? true : false; 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? (ext::shared_ptr< EndCriteria > *)jarg14 : &tempnull14; 
  arg15 = jarg15 ? (ext::shared_ptr< OptimizationMethod > *)jarg15 : &tempnull15; 
  arg16 = (Real)jarg16; 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = (SafeSABRInterpolation *)new SafeSABRInterpolation((Array const &)*arg1,(Array const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(ext::shared_ptr< EndCriteria > const &)*arg14,(ext::shared_ptr< OptimizationMethod > 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_SABRInterpolation__SWIG_3(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, unsigned int jarg9, unsigned int jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13, void * jarg14, void * jarg15, double jarg16) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  ext::shared_ptr< EndCriteria > *arg14 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg15 = 0 ;
  Real arg16 ;
  ext::shared_ptr< EndCriteria > tempnull14 ;
  ext::shared_ptr< OptimizationMethod > tempnull15 ;
  SafeSABRInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = jarg9 ? true : false; 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? (ext::shared_ptr< EndCriteria > *)jarg14 : &tempnull14; 
  arg15 = jarg15 ? (ext::shared_ptr< OptimizationMethod > *)jarg15 : &tempnull15; 
  arg16 = (Real)jarg16; 
  {
    try {
      result = (SafeSABRInterpolation *)new SafeSABRInterpolation((Array const &)*arg1,(Array const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(ext::shared_ptr< EndCriteria > const &)*arg14,(ext::shared_ptr< OptimizationMethod > 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_SABRInterpolation__SWIG_4(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, unsigned int jarg9, unsigned int jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13, void * jarg14, void * jarg15) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  ext::shared_ptr< EndCriteria > *arg14 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg15 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull14 ;
  ext::shared_ptr< OptimizationMethod > tempnull15 ;
  SafeSABRInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = jarg9 ? true : false; 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? (ext::shared_ptr< EndCriteria > *)jarg14 : &tempnull14; 
  arg15 = jarg15 ? (ext::shared_ptr< OptimizationMethod > *)jarg15 : &tempnull15; 
  {
    try {
      result = (SafeSABRInterpolation *)new SafeSABRInterpolation((Array const &)*arg1,(Array const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(ext::shared_ptr< EndCriteria > const &)*arg14,(ext::shared_ptr< OptimizationMethod > 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_SABRInterpolation__SWIG_5(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, unsigned int jarg9, unsigned int jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13, void * jarg14) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  ext::shared_ptr< EndCriteria > *arg14 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull14 ;
  SafeSABRInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = jarg9 ? true : false; 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? (ext::shared_ptr< EndCriteria > *)jarg14 : &tempnull14; 
  {
    try {
      result = (SafeSABRInterpolation *)new SafeSABRInterpolation((Array const &)*arg1,(Array const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(ext::shared_ptr< EndCriteria > 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_SABRInterpolation__SWIG_6(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, unsigned int jarg9, unsigned int jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  SafeSABRInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = jarg9 ? true : false; 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (SafeSABRInterpolation *)new SafeSABRInterpolation((Array const &)*arg1,(Array const &)*arg2,arg3,arg4,arg5,arg6,arg7,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_SABRInterpolation__SWIG_7(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, unsigned int jarg9, unsigned int jarg10, unsigned int jarg11, unsigned int jarg12) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  SafeSABRInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = jarg9 ? true : false; 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (SafeSABRInterpolation *)new SafeSABRInterpolation((Array const &)*arg1,(Array const &)*arg2,arg3,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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SABRInterpolation__SWIG_8(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, unsigned int jarg9, unsigned int jarg10, unsigned int jarg11) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool arg11 ;
  SafeSABRInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = jarg9 ? true : false; 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (SafeSABRInterpolation *)new SafeSABRInterpolation((Array const &)*arg1,(Array 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_SABRInterpolation__SWIG_9(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, unsigned int jarg9, unsigned int jarg10) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  bool arg10 ;
  SafeSABRInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = jarg9 ? true : false; 
  arg10 = jarg10 ? true : false; 
  {
    try {
      result = (SafeSABRInterpolation *)new SafeSABRInterpolation((Array const &)*arg1,(Array 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_SABRInterpolation__SWIG_10(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, unsigned int jarg9) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 ;
  SafeSABRInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = jarg9 ? true : false; 
  {
    try {
      result = (SafeSABRInterpolation *)new SafeSABRInterpolation((Array const &)*arg1,(Array 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_SABRInterpolation__SWIG_11(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  SafeSABRInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (SafeSABRInterpolation *)new SafeSABRInterpolation((Array const &)*arg1,(Array 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 double SWIGSTDCALL CSharp_QuantLib_SABRInterpolation_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeSABRInterpolation *arg1 = (SafeSABRInterpolation *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeSABRInterpolation *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)((SafeSABRInterpolation const *)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_SABRInterpolation_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeSABRInterpolation *arg1 = (SafeSABRInterpolation *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeSABRInterpolation *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((SafeSABRInterpolation 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 double SWIGSTDCALL CSharp_QuantLib_SABRInterpolation_alpha(void * jarg1) {
  double jresult ;
  SafeSABRInterpolation *arg1 = (SafeSABRInterpolation *) 0 ;
  Real result;
  
  arg1 = (SafeSABRInterpolation *)jarg1; 
  {
    try {
      result = (Real)((SafeSABRInterpolation 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_SABRInterpolation_beta(void * jarg1) {
  double jresult ;
  SafeSABRInterpolation *arg1 = (SafeSABRInterpolation *) 0 ;
  Real result;
  
  arg1 = (SafeSABRInterpolation *)jarg1; 
  {
    try {
      result = (Real)((SafeSABRInterpolation 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 double SWIGSTDCALL CSharp_QuantLib_SABRInterpolation_rho(void * jarg1) {
  double jresult ;
  SafeSABRInterpolation *arg1 = (SafeSABRInterpolation *) 0 ;
  Real result;
  
  arg1 = (SafeSABRInterpolation *)jarg1; 
  {
    try {
      result = (Real)((SafeSABRInterpolation const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SABRInterpolation_nu(void * jarg1) {
  double jresult ;
  SafeSABRInterpolation *arg1 = (SafeSABRInterpolation *) 0 ;
  Real result;
  
  arg1 = (SafeSABRInterpolation *)jarg1; 
  {
    try {
      result = (Real)((SafeSABRInterpolation const *)arg1)->nu();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_SABRInterpolation(void * jarg1) {
  SafeSABRInterpolation *arg1 = (SafeSABRInterpolation *) 0 ;
  
  arg1 = (SafeSABRInterpolation *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_RichardsonExtrapolation_call__SWIG_0(void * jarg1, double jarg2) {
  double jresult ;
  RichardsonExtrapolation *arg1 = (RichardsonExtrapolation *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (RichardsonExtrapolation *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((RichardsonExtrapolation 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 double SWIGSTDCALL CSharp_QuantLib_RichardsonExtrapolation_call__SWIG_1(void * jarg1) {
  double jresult ;
  RichardsonExtrapolation *arg1 = (RichardsonExtrapolation *) 0 ;
  Real result;
  
  arg1 = (RichardsonExtrapolation *)jarg1; 
  {
    try {
      result = (Real)((RichardsonExtrapolation const *)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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_RichardsonExtrapolation_call__SWIG_2(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  RichardsonExtrapolation *arg1 = (RichardsonExtrapolation *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real result;
  
  arg1 = (RichardsonExtrapolation *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((RichardsonExtrapolation const *)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_new_RichardsonExtrapolation__SWIG_0(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  UnaryFunctionDelegate *arg1 = (UnaryFunctionDelegate *) 0 ;
  Real arg2 ;
  Real arg3 ;
  RichardsonExtrapolation *result = 0 ;
  
  arg1 = (UnaryFunctionDelegate *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (RichardsonExtrapolation *)new_RichardsonExtrapolation__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_RichardsonExtrapolation__SWIG_1(void * jarg1, double jarg2) {
  void * jresult ;
  UnaryFunctionDelegate *arg1 = (UnaryFunctionDelegate *) 0 ;
  Real arg2 ;
  RichardsonExtrapolation *result = 0 ;
  
  arg1 = (UnaryFunctionDelegate *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (RichardsonExtrapolation *)new_RichardsonExtrapolation__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_RichardsonExtrapolation(void * jarg1) {
  RichardsonExtrapolation *arg1 = (RichardsonExtrapolation *) 0 ;
  
  arg1 = (RichardsonExtrapolation *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ChebyshevInterpolation__SWIG_0(void * jarg1, int jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  ChebyshevInterpolation::PointsType arg2 ;
  ChebyshevInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (ChebyshevInterpolation::PointsType)jarg2; 
  {
    try {
      result = (ChebyshevInterpolation *)new ChebyshevInterpolation((Array 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_ChebyshevInterpolation__SWIG_1(void * jarg1) {
  void * jresult ;
  Array *arg1 = 0 ;
  ChebyshevInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ChebyshevInterpolation *)new ChebyshevInterpolation((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_ChebyshevInterpolation__SWIG_2(unsigned long jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  Size arg1 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  ChebyshevInterpolation::PointsType arg3 ;
  ChebyshevInterpolation *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (ChebyshevInterpolation::PointsType)jarg3; 
  {
    try {
      result = (ChebyshevInterpolation *)new_ChebyshevInterpolation__SWIG_2(SWIG_STD_MOVE(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_ChebyshevInterpolation__SWIG_3(unsigned long jarg1, void * jarg2) {
  void * jresult ;
  Size arg1 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  ChebyshevInterpolation *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  {
    try {
      result = (ChebyshevInterpolation *)new_ChebyshevInterpolation__SWIG_2(SWIG_STD_MOVE(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_ChebyshevInterpolation_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  ChebyshevInterpolation *arg1 = (ChebyshevInterpolation *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (ChebyshevInterpolation *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)((ChebyshevInterpolation const *)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_ChebyshevInterpolation_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  ChebyshevInterpolation *arg1 = (ChebyshevInterpolation *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (ChebyshevInterpolation *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((ChebyshevInterpolation 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_ChebyshevInterpolation_nodes(unsigned long jarg1, int jarg2) {
  void * jresult ;
  Size arg1 ;
  ChebyshevInterpolation::PointsType arg2 ;
  Array result;
  
  arg1 = (Size)jarg1; 
  arg2 = (ChebyshevInterpolation::PointsType)jarg2; 
  {
    try {
      result = ChebyshevInterpolation::nodes(SWIG_STD_MOVE(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 Array(result); 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvexMonotoneInterpolation__SWIG_0(void * jarg1, void * jarg2, double jarg3, double jarg4, unsigned int jarg5) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  bool arg5 ;
  SafeConvexMonotoneInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (SafeConvexMonotoneInterpolation *)new SafeConvexMonotoneInterpolation((Array const &)*arg1,(Array 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_ConvexMonotoneInterpolation__SWIG_1(void * jarg1, void * jarg2, double jarg3, double jarg4) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  SafeConvexMonotoneInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (SafeConvexMonotoneInterpolation *)new SafeConvexMonotoneInterpolation((Array const &)*arg1,(Array 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_ConvexMonotoneInterpolation__SWIG_2(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  SafeConvexMonotoneInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (SafeConvexMonotoneInterpolation *)new SafeConvexMonotoneInterpolation((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_ConvexMonotoneInterpolation__SWIG_3(void * jarg1, void * jarg2) {
  void * jresult ;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  SafeConvexMonotoneInterpolation *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SafeConvexMonotoneInterpolation *)new SafeConvexMonotoneInterpolation((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_ConvexMonotoneInterpolation_call__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  SafeConvexMonotoneInterpolation *arg1 = (SafeConvexMonotoneInterpolation *) 0 ;
  Real arg2 ;
  bool arg3 ;
  Real result;
  
  arg1 = (SafeConvexMonotoneInterpolation *)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_ConvexMonotoneInterpolation_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SafeConvexMonotoneInterpolation *arg1 = (SafeConvexMonotoneInterpolation *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (SafeConvexMonotoneInterpolation *)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_ConvexMonotoneInterpolation(void * jarg1) {
  SafeConvexMonotoneInterpolation *arg1 = (SafeConvexMonotoneInterpolation *) 0 ;
  
  arg1 = (SafeConvexMonotoneInterpolation *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_TermStructure_dayCounter(void * jarg1) {
  void * jresult ;
  TermStructure *arg1 = (TermStructure *) 0 ;
  ext::shared_ptr< TermStructure const > *smartarg1 = 0 ;
  SwigValueWrapper< DayCounter > result;
  
  
  smartarg1 = (ext::shared_ptr< const TermStructure > *)jarg1;
  arg1 = (TermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((TermStructure 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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_TermStructure_timeFromReference(void * jarg1, void * jarg2) {
  double jresult ;
  TermStructure *arg1 = (TermStructure *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< TermStructure const > *smartarg1 = 0 ;
  Time result;
  
  
  smartarg1 = (ext::shared_ptr< const TermStructure > *)jarg1;
  arg1 = (TermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)((TermStructure const *)arg1)->timeFromReference((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_TermStructure_calendar(void * jarg1) {
  void * jresult ;
  TermStructure *arg1 = (TermStructure *) 0 ;
  ext::shared_ptr< TermStructure const > *smartarg1 = 0 ;
  SwigValueWrapper< Calendar > result;
  
  
  smartarg1 = (ext::shared_ptr< const TermStructure > *)jarg1;
  arg1 = (TermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((TermStructure const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_TermStructure_referenceDate(void * jarg1) {
  void * jresult ;
  TermStructure *arg1 = (TermStructure *) 0 ;
  ext::shared_ptr< TermStructure const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const TermStructure > *)jarg1;
  arg1 = (TermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((TermStructure const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_TermStructure_maxDate(void * jarg1) {
  void * jresult ;
  TermStructure *arg1 = (TermStructure *) 0 ;
  ext::shared_ptr< TermStructure const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const TermStructure > *)jarg1;
  arg1 = (TermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((TermStructure const *)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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_TermStructure_maxTime(void * jarg1) {
  double jresult ;
  TermStructure *arg1 = (TermStructure *) 0 ;
  ext::shared_ptr< TermStructure const > *smartarg1 = 0 ;
  Time result;
  
  
  smartarg1 = (ext::shared_ptr< const TermStructure > *)jarg1;
  arg1 = (TermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Time)((TermStructure const *)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_TermStructure_enableExtrapolation(void * jarg1) {
  TermStructure *arg1 = (TermStructure *) 0 ;
  ext::shared_ptr< TermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  TermStructure > *)jarg1;
  arg1 = (TermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_TermStructure_disableExtrapolation(void * jarg1) {
  TermStructure *arg1 = (TermStructure *) 0 ;
  ext::shared_ptr< TermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  TermStructure > *)jarg1;
  arg1 = (TermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_TermStructure_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  TermStructure *arg1 = (TermStructure *) 0 ;
  ext::shared_ptr< TermStructure > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr<  TermStructure > *)jarg1;
  arg1 = (TermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_delete_TermStructure(void * jarg1) {
  TermStructure *arg1 = (TermStructure *) 0 ;
  ext::shared_ptr< TermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  TermStructure > *)jarg1;
  arg1 = (TermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_YieldTermStructure_discount__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  ext::shared_ptr< YieldTermStructure > *smartarg1 = 0 ;
  DiscountFactor result;
  
  
  smartarg1 = (ext::shared_ptr<  YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 ;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *smartarg1 = 0 ;
  DiscountFactor result;
  
  
  smartarg1 = (ext::shared_ptr<  YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 ;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Time arg2 ;
  bool arg3 ;
  ext::shared_ptr< YieldTermStructure > *smartarg1 = 0 ;
  DiscountFactor result;
  
  
  smartarg1 = (ext::shared_ptr<  YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Time arg2 ;
  ext::shared_ptr< YieldTermStructure > *smartarg1 = 0 ;
  DiscountFactor result;
  
  
  smartarg1 = (ext::shared_ptr<  YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  InterestRate result;
  
  
  smartarg1 = (ext::shared_ptr< const YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = ((YieldTermStructure const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_zeroRate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5) {
  void * jresult ;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  InterestRate result;
  
  
  smartarg1 = (ext::shared_ptr< const YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = ((YieldTermStructure const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_zeroRate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  InterestRate result;
  
  
  smartarg1 = (ext::shared_ptr< const YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  {
    try {
      result = ((YieldTermStructure const *)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(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 ;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Time arg2 ;
  Compounding arg3 ;
  Frequency arg4 ;
  bool arg5 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  InterestRate result;
  
  
  smartarg1 = (ext::shared_ptr< const YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = ((YieldTermStructure const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_zeroRate__SWIG_4(void * jarg1, double jarg2, int jarg3, int jarg4) {
  void * jresult ;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Time arg2 ;
  Compounding arg3 ;
  Frequency arg4 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  InterestRate result;
  
  
  smartarg1 = (ext::shared_ptr< const YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  {
    try {
      result = ((YieldTermStructure const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_zeroRate__SWIG_5(void * jarg1, double jarg2, int jarg3) {
  void * jresult ;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Time arg2 ;
  Compounding arg3 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  InterestRate result;
  
  
  smartarg1 = (ext::shared_ptr< const YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Compounding)jarg3; 
  {
    try {
      result = ((YieldTermStructure const *)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(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 ;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  InterestRate result;
  
  
  smartarg1 = (ext::shared_ptr< const YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = ((YieldTermStructure const *)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(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 ;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  InterestRate result;
  
  
  smartarg1 = (ext::shared_ptr< const YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = ((YieldTermStructure const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_forwardRate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  InterestRate result;
  
  
  smartarg1 = (ext::shared_ptr< const YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  {
    try {
      result = ((YieldTermStructure const *)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(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 ;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  InterestRate result;
  
  
  smartarg1 = (ext::shared_ptr< const YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = ((YieldTermStructure const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_forwardRate__SWIG_4(void * jarg1, double jarg2, double jarg3, int jarg4, int jarg5) {
  void * jresult ;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Compounding arg4 ;
  Frequency arg5 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  InterestRate result;
  
  
  smartarg1 = (ext::shared_ptr< const YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = ((YieldTermStructure const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_forwardRate__SWIG_5(void * jarg1, double jarg2, double jarg3, int jarg4) {
  void * jresult ;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Compounding arg4 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  InterestRate result;
  
  
  smartarg1 = (ext::shared_ptr< const YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Compounding)jarg4; 
  {
    try {
      result = ((YieldTermStructure const *)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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YieldTermStructure(void * jarg1) {
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  ext::shared_ptr< YieldTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YieldTermStructure > *)jarg1;
  arg1 = (YieldTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YieldTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< YieldTermStructure > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempnull1 ;
  Handle< YieldTermStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< YieldTermStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Handle< YieldTermStructure > *)new Handle< YieldTermStructure >((ext::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 ;
  ext::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 = result ? new ext::shared_ptr< YieldTermStructure >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_currentLink(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  ext::shared_ptr< YieldTermStructure > result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< YieldTermStructure >(result) : 0; 
  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 ;
  ext::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 = result ? new ext::shared_ptr< Observable >(result) : 0; 
  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 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 & 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 & 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 & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(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 & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(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 & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(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(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(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(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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(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(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(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(result); 
  return jresult;
}


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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YieldTermStructureHandle_timeFromReference(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time result;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)(*arg1)->timeFromReference((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_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(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(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(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 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 ;
  ext::shared_ptr< YieldTermStructure > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempnull1 ;
  RelinkableHandle< YieldTermStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< YieldTermStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (RelinkableHandle< YieldTermStructure > *)new RelinkableHandle< YieldTermStructure >((ext::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 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  
  arg1 = (RelinkableHandle< YieldTermStructure > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->linkTo((ext::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_RelinkableYieldTermStructureHandle_reset(void * jarg1) {
  RelinkableHandle< YieldTermStructure > *arg1 = (RelinkableHandle< YieldTermStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< YieldTermStructure > *)jarg1; 
  {
    try {
      RelinkableHandle_Sl_YieldTermStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  ImpliedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ImpliedTermStructure *)new ImpliedTermStructure((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 = result ? new ext::shared_ptr<  ImpliedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ImpliedTermStructure(void * jarg1) {
  ImpliedTermStructure *arg1 = (ImpliedTermStructure *) 0 ;
  ext::shared_ptr< ImpliedTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ImpliedTermStructure > *)jarg1;
  arg1 = (ImpliedTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ZeroSpreadedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroSpreadedTermStructure *)new ZeroSpreadedTermStructure((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 = result ? new ext::shared_ptr<  ZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ZeroSpreadedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  {
    try {
      result = (ZeroSpreadedTermStructure *)new ZeroSpreadedTermStructure((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 = result ? new ext::shared_ptr<  ZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ZeroSpreadedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  {
    try {
      result = (ZeroSpreadedTermStructure *)new ZeroSpreadedTermStructure((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 = result ? new ext::shared_ptr<  ZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ZeroSpreadedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroSpreadedTermStructure *)new ZeroSpreadedTermStructure((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 = result ? new ext::shared_ptr<  ZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroSpreadedTermStructure(void * jarg1) {
  ZeroSpreadedTermStructure *arg1 = (ZeroSpreadedTermStructure *) 0 ;
  ext::shared_ptr< ZeroSpreadedTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZeroSpreadedTermStructure > *)jarg1;
  arg1 = (ZeroSpreadedTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ForwardSpreadedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ForwardSpreadedTermStructure *)new ForwardSpreadedTermStructure((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 = result ? new ext::shared_ptr<  ForwardSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ForwardSpreadedTermStructure(void * jarg1) {
  ForwardSpreadedTermStructure *arg1 = (ForwardSpreadedTermStructure *) 0 ;
  ext::shared_ptr< ForwardSpreadedTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ForwardSpreadedTermStructure > *)jarg1;
  arg1 = (ForwardSpreadedTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseZeroSpreadedTermStructure__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 ;
  PiecewiseZeroSpreadedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Linear *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseZeroSpreadedTermStructure *)new PiecewiseZeroSpreadedTermStructure((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 = result ? new ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseZeroSpreadedTermStructure__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 ;
  PiecewiseZeroSpreadedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseZeroSpreadedTermStructure *)new PiecewiseZeroSpreadedTermStructure((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 = result ? new ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseZeroSpreadedTermStructure__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 ;
  PiecewiseZeroSpreadedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (PiecewiseZeroSpreadedTermStructure *)new PiecewiseZeroSpreadedTermStructure((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 = result ? new ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseZeroSpreadedTermStructure__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 ;
  PiecewiseZeroSpreadedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  {
    try {
      result = (PiecewiseZeroSpreadedTermStructure *)new PiecewiseZeroSpreadedTermStructure((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 = result ? new ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseZeroSpreadedTermStructure__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 ;
  PiecewiseZeroSpreadedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseZeroSpreadedTermStructure *)new PiecewiseZeroSpreadedTermStructure((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 = result ? new ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PiecewiseZeroSpreadedTermStructure(void * jarg1) {
  PiecewiseZeroSpreadedTermStructure *arg1 = (PiecewiseZeroSpreadedTermStructure *) 0 ;
  ext::shared_ptr< PiecewiseZeroSpreadedTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure > *)jarg1;
  arg1 = (PiecewiseZeroSpreadedTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  SpreadedLinearZeroInterpolatedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Linear *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadedLinearZeroInterpolatedTermStructure *)new SpreadedLinearZeroInterpolatedTermStructure((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 = result ? new ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  SpreadedLinearZeroInterpolatedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadedLinearZeroInterpolatedTermStructure *)new SpreadedLinearZeroInterpolatedTermStructure((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 = result ? new ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  SpreadedLinearZeroInterpolatedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (SpreadedLinearZeroInterpolatedTermStructure *)new SpreadedLinearZeroInterpolatedTermStructure((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 = result ? new ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  SpreadedLinearZeroInterpolatedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  {
    try {
      result = (SpreadedLinearZeroInterpolatedTermStructure *)new SpreadedLinearZeroInterpolatedTermStructure((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 = result ? new ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  SpreadedLinearZeroInterpolatedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadedLinearZeroInterpolatedTermStructure *)new SpreadedLinearZeroInterpolatedTermStructure((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 = result ? new ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SpreadedLinearZeroInterpolatedTermStructure(void * jarg1) {
  SpreadedLinearZeroInterpolatedTermStructure *arg1 = (SpreadedLinearZeroInterpolatedTermStructure *) 0 ;
  ext::shared_ptr< SpreadedLinearZeroInterpolatedTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure > *)jarg1;
  arg1 = (SpreadedLinearZeroInterpolatedTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadedBackwardFlatZeroInterpolatedTermStructure__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 ;
  BackwardFlat *arg7 = 0 ;
  SpreadedBackwardFlatZeroInterpolatedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BackwardFlat *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadedBackwardFlatZeroInterpolatedTermStructure *)new SpreadedBackwardFlatZeroInterpolatedTermStructure((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote > > const &)*arg2,(std::vector< Date > const &)*arg3,arg4,arg5,(DayCounter const &)*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 = result ? new ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadedBackwardFlatZeroInterpolatedTermStructure__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 ;
  SpreadedBackwardFlatZeroInterpolatedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadedBackwardFlatZeroInterpolatedTermStructure *)new SpreadedBackwardFlatZeroInterpolatedTermStructure((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 = result ? new ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadedBackwardFlatZeroInterpolatedTermStructure__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 ;
  SpreadedBackwardFlatZeroInterpolatedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (SpreadedBackwardFlatZeroInterpolatedTermStructure *)new SpreadedBackwardFlatZeroInterpolatedTermStructure((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 = result ? new ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadedBackwardFlatZeroInterpolatedTermStructure__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 ;
  SpreadedBackwardFlatZeroInterpolatedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  {
    try {
      result = (SpreadedBackwardFlatZeroInterpolatedTermStructure *)new SpreadedBackwardFlatZeroInterpolatedTermStructure((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 = result ? new ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadedBackwardFlatZeroInterpolatedTermStructure__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 ;
  SpreadedBackwardFlatZeroInterpolatedTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Handle< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadedBackwardFlatZeroInterpolatedTermStructure *)new SpreadedBackwardFlatZeroInterpolatedTermStructure((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 = result ? new ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SpreadedBackwardFlatZeroInterpolatedTermStructure(void * jarg1) {
  SpreadedBackwardFlatZeroInterpolatedTermStructure *arg1 = (SpreadedBackwardFlatZeroInterpolatedTermStructure *) 0 ;
  ext::shared_ptr< SpreadedBackwardFlatZeroInterpolatedTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure > *)jarg1;
  arg1 = (SpreadedBackwardFlatZeroInterpolatedTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  FlatForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (FlatForward *)new FlatForward((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 = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FlatForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  {
    try {
      result = (FlatForward *)new FlatForward((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 = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FlatForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FlatForward *)new FlatForward((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 = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FlatForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (FlatForward *)new FlatForward((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 = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FlatForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  {
    try {
      result = (FlatForward *)new FlatForward((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 = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FlatForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FlatForward *)new FlatForward((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 = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FlatForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (FlatForward *)new FlatForward(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 = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FlatForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  {
    try {
      result = (FlatForward *)new FlatForward(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 = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FlatForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FlatForward *)new FlatForward(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 = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FlatForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (FlatForward *)new FlatForward(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 = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FlatForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  {
    try {
      result = (FlatForward *)new FlatForward(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 = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FlatForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FlatForward *)new FlatForward(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 = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FlatForward(void * jarg1) {
  FlatForward *arg1 = (FlatForward *) 0 ;
  ext::shared_ptr< FlatForward > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FlatForward > *)jarg1;
  arg1 = (FlatForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UltimateForwardTermStructure(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Real arg5 ;
  UltimateForwardTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (UltimateForwardTermStructure *)new UltimateForwardTermStructure((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< Quote > const &)*arg3,(Period 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 ? new ext::shared_ptr<  UltimateForwardTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UltimateForwardTermStructure(void * jarg1) {
  UltimateForwardTermStructure *arg1 = (UltimateForwardTermStructure *) 0 ;
  ext::shared_ptr< UltimateForwardTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  UltimateForwardTermStructure > *)jarg1;
  arg1 = (UltimateForwardTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuantoTermStructure(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, void * jarg6, double jarg7, double jarg8) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > arg2 ;
  Handle< YieldTermStructure > arg3 ;
  Handle< BlackVolTermStructure > arg4 ;
  Real arg5 ;
  Handle< BlackVolTermStructure > arg6 ;
  Real arg7 ;
  Real arg8 ;
  Handle< YieldTermStructure > *argp2 ;
  Handle< YieldTermStructure > *argp3 ;
  Handle< BlackVolTermStructure > *argp4 ;
  Handle< BlackVolTermStructure > *argp6 ;
  QuantoTermStructure *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  argp2 = (Handle< YieldTermStructure > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg2 = *argp2; 
  argp3 = (Handle< YieldTermStructure > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg3 = *argp3; 
  argp4 = (Handle< BlackVolTermStructure > *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< BlackVolTermStructure >", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (Real)jarg5; 
  argp6 = (Handle< BlackVolTermStructure > *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< BlackVolTermStructure >", 0);
    return 0;
  }
  arg6 = *argp6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (QuantoTermStructure *)new QuantoTermStructure((Handle< YieldTermStructure > const &)*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 ? new ext::shared_ptr<  QuantoTermStructure >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QuantoTermStructure(void * jarg1) {
  QuantoTermStructure *arg1 = (QuantoTermStructure *) 0 ;
  ext::shared_ptr< QuantoTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  QuantoTermStructure > *)jarg1;
  arg1 = (QuantoTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< double > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & 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 >(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 >(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 & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< IntervalPrice > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< IntervalPrice > const & 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 >(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 >(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 & 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 & 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(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 ;
  std::vector< IntervalPrice >::value_type *result = 0 ;
  
  arg1 = (std::vector< IntervalPrice > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< IntervalPrice >::value_type *) &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 & 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 & 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 & 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 & 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 & 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 & 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 & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & 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 >(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(SWIG_STD_MOVE(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 >(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(SWIG_STD_MOVE(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 >(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, const 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 & 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, const 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, const 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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IndexManager_clearHistory(void * jarg1, const 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 unsigned int SWIGSTDCALL CSharp_QuantLib_IndexManager_hasHistoricalFixing(void * jarg1, const char * jarg2, void * jarg3) {
  unsigned int jresult ;
  IndexManager *arg1 = (IndexManager *) 0 ;
  std::string *arg2 = 0 ;
  Date *arg3 = 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; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)((IndexManager const *)arg1)->hasHistoricalFixing((std::string 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_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 const char * SWIGSTDCALL CSharp_QuantLib_Index_name(void * jarg1) {
  const char * jresult ;
  Index *arg1 = (Index *) 0 ;
  ext::shared_ptr< Index const > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (ext::shared_ptr< const Index > *)jarg1;
  arg1 = (Index *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Index 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 void * SWIGSTDCALL CSharp_QuantLib_Index_fixingCalendar(void * jarg1) {
  void * jresult ;
  Index *arg1 = (Index *) 0 ;
  ext::shared_ptr< Index const > *smartarg1 = 0 ;
  SwigValueWrapper< Calendar > result;
  
  
  smartarg1 = (ext::shared_ptr< const Index > *)jarg1;
  arg1 = (Index *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Index const *)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(result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Index_isValidFixingDate(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Index *arg1 = (Index *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< Index const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const Index > *)jarg1;
  arg1 = (Index *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)((Index const *)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 unsigned int SWIGSTDCALL CSharp_QuantLib_Index_hasHistoricalFixing(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Index *arg1 = (Index *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< Index const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const Index > *)jarg1;
  arg1 = (Index *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)((Index const *)arg1)->hasHistoricalFixing((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 ;
  Index *arg1 = (Index *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  ext::shared_ptr< Index const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Index > *)jarg1;
  arg1 = (Index *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)((Index const *)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 ;
  Index *arg1 = (Index *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< Index const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Index > *)jarg1;
  arg1 = (Index *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Index const *)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__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  Index *arg1 = (Index *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  ext::shared_ptr< Index > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Index > *)jarg1;
  arg1 = (Index *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return ;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      (arg1)->addFixing((Date const &)*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_Index_addFixing__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  Index *arg1 = (Index *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  ext::shared_ptr< Index > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Index > *)jarg1;
  arg1 = (Index *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 void * SWIGSTDCALL CSharp_QuantLib_Index_timeSeries(void * jarg1) {
  void * jresult ;
  Index *arg1 = (Index *) 0 ;
  ext::shared_ptr< Index const > *smartarg1 = 0 ;
  TimeSeries< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const Index > *)jarg1;
  arg1 = (Index *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (TimeSeries< Real > *) &((Index const *)arg1)->timeSeries();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Index_clearFixings(void * jarg1) {
  Index *arg1 = (Index *) 0 ;
  ext::shared_ptr< Index > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Index > *)jarg1;
  arg1 = (Index *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (arg1)->clearFixings();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_addFixings__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  Index *arg1 = (Index *) 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< Index > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Index > *)jarg1;
  arg1 = (Index *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return ;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return ;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      Index_addFixings__SWIG_0(arg1,(std::vector< Date > const &)*arg2,(std::vector< double > const &)*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_Index_addFixings__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  Index *arg1 = (Index *) 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  ext::shared_ptr< Index > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Index > *)jarg1;
  arg1 = (Index *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return ;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return ;
  } 
  {
    try {
      Index_addFixings__SWIG_0(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 const char * SWIGSTDCALL CSharp_QuantLib_Index___str__(void * jarg1) {
  const char * jresult ;
  Index *arg1 = (Index *) 0 ;
  ext::shared_ptr< Index > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (ext::shared_ptr<  Index > *)jarg1;
  arg1 = (Index *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = Index___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_Index(void * jarg1) {
  Index *arg1 = (Index *) 0 ;
  ext::shared_ptr< Index > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Index > *)jarg1;
  arg1 = (Index *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT const char * SWIGSTDCALL CSharp_QuantLib_InterestRateIndex_familyName(void * jarg1) {
  const char * jresult ;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  ext::shared_ptr< InterestRateIndex const > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (ext::shared_ptr< const InterestRateIndex > *)jarg1;
  arg1 = (InterestRateIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterestRateIndex const *)arg1)->familyName();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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 ;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  ext::shared_ptr< InterestRateIndex const > *smartarg1 = 0 ;
  Period result;
  
  
  smartarg1 = (ext::shared_ptr< const InterestRateIndex > *)jarg1;
  arg1 = (InterestRateIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterestRateIndex const *)arg1)->tenor();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_InterestRateIndex_fixingDays(void * jarg1) {
  unsigned int jresult ;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  ext::shared_ptr< InterestRateIndex const > *smartarg1 = 0 ;
  Natural result;
  
  
  smartarg1 = (ext::shared_ptr< const InterestRateIndex > *)jarg1;
  arg1 = (InterestRateIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Natural)((InterestRateIndex const *)arg1)->fixingDays();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< InterestRateIndex const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const InterestRateIndex > *)jarg1;
  arg1 = (InterestRateIndex *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((InterestRateIndex const *)arg1)->fixingDate((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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRateIndex_currency(void * jarg1) {
  void * jresult ;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  ext::shared_ptr< InterestRateIndex const > *smartarg1 = 0 ;
  Currency result;
  
  
  smartarg1 = (ext::shared_ptr< const InterestRateIndex > *)jarg1;
  arg1 = (InterestRateIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterestRateIndex 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 = new Currency(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRateIndex_dayCounter(void * jarg1) {
  void * jresult ;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  ext::shared_ptr< InterestRateIndex const > *smartarg1 = 0 ;
  SwigValueWrapper< DayCounter > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterestRateIndex > *)jarg1;
  arg1 = (InterestRateIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterestRateIndex 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRateIndex_maturityDate(void * jarg1, void * jarg2) {
  void * jresult ;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< InterestRateIndex const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const InterestRateIndex > *)jarg1;
  arg1 = (InterestRateIndex *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((InterestRateIndex const *)arg1)->maturityDate((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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InterestRateIndex_valueDate(void * jarg1, void * jarg2) {
  void * jresult ;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< InterestRateIndex const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const InterestRateIndex > *)jarg1;
  arg1 = (InterestRateIndex *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((InterestRateIndex const *)arg1)->valueDate((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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InterestRateIndex(void * jarg1) {
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  ext::shared_ptr< InterestRateIndex > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterestRateIndex > *)jarg1;
  arg1 = (InterestRateIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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(const 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 ;
  IborIndex *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 & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Currency *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Handle< YieldTermStructure > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (IborIndex *)new IborIndex((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 = result ? new ext::shared_ptr<  IborIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IborIndex__SWIG_1(const 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 ;
  IborIndex *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 & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Currency *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (IborIndex *)new IborIndex((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 = result ? new ext::shared_ptr<  IborIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_IborIndex_businessDayConvention(void * jarg1) {
  int jresult ;
  IborIndex *arg1 = (IborIndex *) 0 ;
  ext::shared_ptr< IborIndex const > *smartarg1 = 0 ;
  BusinessDayConvention result;
  
  
  smartarg1 = (ext::shared_ptr< const IborIndex > *)jarg1;
  arg1 = (IborIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (BusinessDayConvention)((IborIndex const *)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 unsigned int SWIGSTDCALL CSharp_QuantLib_IborIndex_endOfMonth(void * jarg1) {
  unsigned int jresult ;
  IborIndex *arg1 = (IborIndex *) 0 ;
  ext::shared_ptr< IborIndex const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const IborIndex > *)jarg1;
  arg1 = (IborIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((IborIndex const *)arg1)->endOfMonth();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  IborIndex *arg1 = (IborIndex *) 0 ;
  ext::shared_ptr< IborIndex const > *smartarg1 = 0 ;
  Handle< YieldTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr< const IborIndex > *)jarg1;
  arg1 = (IborIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((IborIndex const *)arg1)->forwardingTermStructure();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborIndex_clone(void * jarg1, void * jarg2) {
  void * jresult ;
  IborIndex *arg1 = (IborIndex *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< IborIndex const > *smartarg1 = 0 ;
  ext::shared_ptr< IborIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const IborIndex > *)jarg1;
  arg1 = (IborIndex *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((IborIndex const *)arg1)->clone((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 ? new ext::shared_ptr< IborIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IborIndex(void * jarg1) {
  IborIndex *arg1 = (IborIndex *) 0 ;
  ext::shared_ptr< IborIndex > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  IborIndex > *)jarg1;
  arg1 = (IborIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  ext::shared_ptr< InterestRateIndex > *arg1 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempnull1 ;
  ext::shared_ptr< IborIndex > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< InterestRateIndex > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_iborindex((ext::shared_ptr< InterestRateIndex > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< IborIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndex__SWIG_0(const 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 ;
  OvernightIndex *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 & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (OvernightIndex *)new OvernightIndex((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 = result ? new ext::shared_ptr<  OvernightIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndex__SWIG_1(const 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 ;
  OvernightIndex *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 & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (OvernightIndex *)new OvernightIndex((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 = result ? new ext::shared_ptr<  OvernightIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightIndex_clone(void * jarg1, void * jarg2) {
  void * jresult ;
  OvernightIndex *arg1 = (OvernightIndex *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< OvernightIndex const > *smartarg1 = 0 ;
  ext::shared_ptr< OvernightIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const OvernightIndex > *)jarg1;
  arg1 = (OvernightIndex *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = OvernightIndex_clone((OvernightIndex 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 ? new ext::shared_ptr< OvernightIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_OvernightIndex(void * jarg1) {
  OvernightIndex *arg1 = (OvernightIndex *) 0 ;
  ext::shared_ptr< OvernightIndex > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndex > *)jarg1;
  arg1 = (OvernightIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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(const 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 ;
  Libor *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 & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Currency *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Libor *)new Libor((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 = result ? new ext::shared_ptr<  Libor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Libor__SWIG_1(const 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 ;
  Libor *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 & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Currency *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Libor *)new Libor((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 = result ? new ext::shared_ptr<  Libor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Libor(void * jarg1) {
  Libor *arg1 = (Libor *) 0 ;
  ext::shared_ptr< Libor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Libor > *)jarg1;
  arg1 = (Libor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DailyTenorLibor__SWIG_0(const char * jarg1, unsigned int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Natural arg2 ;
  Currency *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  DailyTenorLibor *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (Natural)jarg2; 
  arg3 = (Currency *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DailyTenorLibor *)new DailyTenorLibor((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 = result ? new ext::shared_ptr<  DailyTenorLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DailyTenorLibor__SWIG_1(const char * jarg1, unsigned int jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Natural arg2 ;
  Currency *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  DailyTenorLibor *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (Natural)jarg2; 
  arg3 = (Currency *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DailyTenorLibor *)new DailyTenorLibor((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 = result ? new ext::shared_ptr<  DailyTenorLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DailyTenorLibor(void * jarg1) {
  DailyTenorLibor *arg1 = (DailyTenorLibor *) 0 ;
  ext::shared_ptr< DailyTenorLibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DailyTenorLibor > *)jarg1;
  arg1 = (DailyTenorLibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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(const 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 ;
  ext::shared_ptr< IborIndex > *arg9 = 0 ;
  ext::shared_ptr< IborIndex > tempnull9 ;
  SwapIndex *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 & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Currency *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg6 = (Period *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = jarg9 ? (ext::shared_ptr< IborIndex > *)jarg9 : &tempnull9; 
  {
    try {
      result = (SwapIndex *)new SwapIndex((std::string const &)*arg1,(Period const &)*arg2,arg3,(Currency const &)*arg4,(Calendar const &)*arg5,(Period const &)*arg6,arg7,(DayCounter const &)*arg8,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  SwapIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapIndex__SWIG_1(const 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 ;
  ext::shared_ptr< IborIndex > *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  ext::shared_ptr< IborIndex > tempnull9 ;
  SwapIndex *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 & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Currency *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg6 = (Period *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = jarg9 ? (ext::shared_ptr< IborIndex > *)jarg9 : &tempnull9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapIndex *)new SwapIndex((std::string const &)*arg1,(Period const &)*arg2,arg3,(Currency const &)*arg4,(Calendar const &)*arg5,(Period const &)*arg6,arg7,(DayCounter const &)*arg8,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwapIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwapIndex_fixedLegTenor(void * jarg1) {
  void * jresult ;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  ext::shared_ptr< SwapIndex const > *smartarg1 = 0 ;
  Period result;
  
  
  smartarg1 = (ext::shared_ptr< const SwapIndex > *)jarg1;
  arg1 = (SwapIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((SwapIndex const *)arg1)->fixedLegTenor();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_SwapIndex_fixedLegConvention(void * jarg1) {
  int jresult ;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  ext::shared_ptr< SwapIndex const > *smartarg1 = 0 ;
  BusinessDayConvention result;
  
  
  smartarg1 = (ext::shared_ptr< const SwapIndex > *)jarg1;
  arg1 = (SwapIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (BusinessDayConvention)((SwapIndex const *)arg1)->fixedLegConvention();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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 ;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  ext::shared_ptr< SwapIndex const > *smartarg1 = 0 ;
  ext::shared_ptr< IborIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwapIndex > *)jarg1;
  arg1 = (SwapIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((SwapIndex const *)arg1)->iborIndex();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< IborIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwapIndex_forwardingTermStructure(void * jarg1) {
  void * jresult ;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  ext::shared_ptr< SwapIndex const > *smartarg1 = 0 ;
  Handle< YieldTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwapIndex > *)jarg1;
  arg1 = (SwapIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((SwapIndex const *)arg1)->forwardingTermStructure();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwapIndex_discountingTermStructure(void * jarg1) {
  void * jresult ;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  ext::shared_ptr< SwapIndex const > *smartarg1 = 0 ;
  Handle< YieldTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwapIndex > *)jarg1;
  arg1 = (SwapIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((SwapIndex const *)arg1)->discountingTermStructure();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwapIndex_clone__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< SwapIndex const > *smartarg1 = 0 ;
  ext::shared_ptr< SwapIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwapIndex > *)jarg1;
  arg1 = (SwapIndex *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((SwapIndex const *)arg1)->clone((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 ? new ext::shared_ptr< SwapIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwapIndex_clone__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< SwapIndex const > *smartarg1 = 0 ;
  ext::shared_ptr< SwapIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwapIndex > *)jarg1;
  arg1 = (SwapIndex *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((SwapIndex const *)arg1)->clone((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 = result ? new ext::shared_ptr< SwapIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwapIndex_clone__SWIG_2(void * jarg1, void * jarg2) {
  void * jresult ;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  Period *arg2 = 0 ;
  ext::shared_ptr< SwapIndex const > *smartarg1 = 0 ;
  ext::shared_ptr< SwapIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwapIndex > *)jarg1;
  arg1 = (SwapIndex *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((SwapIndex const *)arg1)->clone((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 = result ? new ext::shared_ptr< SwapIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SwapIndex(void * jarg1) {
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  ext::shared_ptr< SwapIndex > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SwapIndex > *)jarg1;
  arg1 = (SwapIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SwapIndexVector_Clear(void * jarg1) {
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)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_SwapIndexVector_Add(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::shared_ptr< SwapIndex > 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_SwapIndexVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< SwapIndex > > 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_SwapIndexVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< SwapIndex > > 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_SwapIndexVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< SwapIndex > >::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_SwapIndexVector__SWIG_0() {
  void * jresult ;
  std::vector< ext::shared_ptr< SwapIndex > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< SwapIndex > > *)new std::vector< ext::shared_ptr< SwapIndex > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapIndexVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< ext::shared_ptr< SwapIndex > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< SwapIndex > > *)new_std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_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_SwapIndexVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< SwapIndex > result;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_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 = result ? new ext::shared_ptr< SwapIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwapIndexVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< SwapIndex > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_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 = *result ? new std::vector< ext::shared_ptr< SwapIndex > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SwapIndexVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__setitem(arg1,arg2,(ext::shared_ptr< SwapIndex > 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_SwapIndexVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< SwapIndex > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__AddRange(arg1,(std::vector< ext::shared_ptr< SwapIndex > > 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_SwapIndexVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< SwapIndex > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< SwapIndex > > *)std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_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_SwapIndexVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__Insert(arg1,arg2,(ext::shared_ptr< SwapIndex > 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_SwapIndexVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< SwapIndex > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< SwapIndex > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::shared_ptr< SwapIndex > > 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_SwapIndexVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_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_SwapIndexVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_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_SwapIndexVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< SwapIndex > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< SwapIndex > tempnull1 ;
  std::vector< ext::shared_ptr< SwapIndex > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< SwapIndex > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< SwapIndex > > *)std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__Repeat((ext::shared_ptr< SwapIndex > 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_SwapIndexVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_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_SwapIndexVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_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_SwapIndexVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< SwapIndex > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< SwapIndex > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::shared_ptr< SwapIndex > > 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_SwapIndexVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__Contains(arg1,(ext::shared_ptr< SwapIndex > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_SwapIndexVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__IndexOf(arg1,(ext::shared_ptr< SwapIndex > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_SwapIndexVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__LastIndexOf(arg1,(ext::shared_ptr< SwapIndex > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_SwapIndexVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__Remove(arg1,(ext::shared_ptr< SwapIndex > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_SwapIndexVector(void * jarg1) {
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_swap_index(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< InterestRateIndex > *arg1 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempnull1 ;
  ext::shared_ptr< SwapIndex > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< InterestRateIndex > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_swap_index((ext::shared_ptr< InterestRateIndex > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< SwapIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapSpreadIndex__SWIG_0(const char * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5) {
  void * jresult ;
  std::string *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  SwapSpreadIndex *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (SwapSpreadIndex *)new SwapSpreadIndex((std::string const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(ext::shared_ptr< SwapIndex > 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 ? new ext::shared_ptr<  SwapSpreadIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapSpreadIndex__SWIG_1(const char * jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  std::string *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  SwapSpreadIndex *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (SwapSpreadIndex *)new SwapSpreadIndex((std::string const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(ext::shared_ptr< SwapIndex > 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 ? new ext::shared_ptr<  SwapSpreadIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapSpreadIndex__SWIG_2(const char * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  SwapSpreadIndex *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  {
    try {
      result = (SwapSpreadIndex *)new SwapSpreadIndex((std::string const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(ext::shared_ptr< SwapIndex > 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 ? new ext::shared_ptr<  SwapSpreadIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwapSpreadIndex_forecastFixing(void * jarg1, void * jarg2) {
  double jresult ;
  SwapSpreadIndex *arg1 = (SwapSpreadIndex *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< SwapSpreadIndex const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const SwapSpreadIndex > *)jarg1;
  arg1 = (SwapSpreadIndex *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)((SwapSpreadIndex const *)arg1)->forecastFixing((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_SwapSpreadIndex_pastFixing(void * jarg1, void * jarg2) {
  double jresult ;
  SwapSpreadIndex *arg1 = (SwapSpreadIndex *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< SwapSpreadIndex const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const SwapSpreadIndex > *)jarg1;
  arg1 = (SwapSpreadIndex *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)((SwapSpreadIndex const *)arg1)->pastFixing((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_SwapSpreadIndex_swapIndex1(void * jarg1) {
  void * jresult ;
  SwapSpreadIndex *arg1 = (SwapSpreadIndex *) 0 ;
  ext::shared_ptr< SwapSpreadIndex > *smartarg1 = 0 ;
  ext::shared_ptr< SwapIndex > result;
  
  
  smartarg1 = (ext::shared_ptr<  SwapSpreadIndex > *)jarg1;
  arg1 = (SwapSpreadIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->swapIndex1();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< SwapIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwapSpreadIndex_swapIndex2(void * jarg1) {
  void * jresult ;
  SwapSpreadIndex *arg1 = (SwapSpreadIndex *) 0 ;
  ext::shared_ptr< SwapSpreadIndex > *smartarg1 = 0 ;
  ext::shared_ptr< SwapIndex > result;
  
  
  smartarg1 = (ext::shared_ptr<  SwapSpreadIndex > *)jarg1;
  arg1 = (SwapSpreadIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->swapIndex2();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< SwapIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwapSpreadIndex_gearing1(void * jarg1) {
  double jresult ;
  SwapSpreadIndex *arg1 = (SwapSpreadIndex *) 0 ;
  ext::shared_ptr< SwapSpreadIndex > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  SwapSpreadIndex > *)jarg1;
  arg1 = (SwapSpreadIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->gearing1();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwapSpreadIndex_gearing2(void * jarg1) {
  double jresult ;
  SwapSpreadIndex *arg1 = (SwapSpreadIndex *) 0 ;
  ext::shared_ptr< SwapSpreadIndex > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  SwapSpreadIndex > *)jarg1;
  arg1 = (SwapSpreadIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->gearing2();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_SwapSpreadIndex(void * jarg1) {
  SwapSpreadIndex *arg1 = (SwapSpreadIndex *) 0 ;
  ext::shared_ptr< SwapSpreadIndex > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SwapSpreadIndex > *)jarg1;
  arg1 = (SwapSpreadIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EquityIndex__SWIG_0(const char * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::string arg1 ;
  SwigValueWrapper< Calendar > arg2 ;
  Handle< YieldTermStructure > arg3 ;
  Handle< YieldTermStructure > arg4 ;
  Handle< Quote > arg5 ;
  Calendar *argp2 ;
  Handle< YieldTermStructure > *argp3 ;
  Handle< YieldTermStructure > *argp4 ;
  Handle< Quote > *argp5 ;
  EquityIndex *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg1)->assign(jarg1); 
  argp2 = (Calendar *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg2 = *argp2; 
  argp3 = (Handle< YieldTermStructure > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg3 = *argp3; 
  argp4 = (Handle< YieldTermStructure > *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg4 = *argp4; 
  argp5 = (Handle< Quote > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg5 = *argp5; 
  {
    try {
      result = (EquityIndex *)new EquityIndex(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 ? new ext::shared_ptr<  EquityIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EquityIndex__SWIG_1(const char * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::string arg1 ;
  SwigValueWrapper< Calendar > arg2 ;
  Handle< YieldTermStructure > arg3 ;
  Handle< YieldTermStructure > arg4 ;
  Calendar *argp2 ;
  Handle< YieldTermStructure > *argp3 ;
  Handle< YieldTermStructure > *argp4 ;
  EquityIndex *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg1)->assign(jarg1); 
  argp2 = (Calendar *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg2 = *argp2; 
  argp3 = (Handle< YieldTermStructure > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg3 = *argp3; 
  argp4 = (Handle< YieldTermStructure > *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg4 = *argp4; 
  {
    try {
      result = (EquityIndex *)new EquityIndex(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 ? new ext::shared_ptr<  EquityIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EquityIndex__SWIG_2(const char * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::string arg1 ;
  SwigValueWrapper< Calendar > arg2 ;
  Handle< YieldTermStructure > arg3 ;
  Calendar *argp2 ;
  Handle< YieldTermStructure > *argp3 ;
  EquityIndex *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg1)->assign(jarg1); 
  argp2 = (Calendar *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg2 = *argp2; 
  argp3 = (Handle< YieldTermStructure > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (EquityIndex *)new EquityIndex(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 ? new ext::shared_ptr<  EquityIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EquityIndex__SWIG_3(const char * jarg1, void * jarg2) {
  void * jresult ;
  std::string arg1 ;
  SwigValueWrapper< Calendar > arg2 ;
  Calendar *argp2 ;
  EquityIndex *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg1)->assign(jarg1); 
  argp2 = (Calendar *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (EquityIndex *)new EquityIndex(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 ? new ext::shared_ptr<  EquityIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_EquityIndex_equityInterestRateCurve(void * jarg1) {
  void * jresult ;
  EquityIndex *arg1 = (EquityIndex *) 0 ;
  ext::shared_ptr< EquityIndex const > *smartarg1 = 0 ;
  Handle< YieldTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr< const EquityIndex > *)jarg1;
  arg1 = (EquityIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((EquityIndex const *)arg1)->equityInterestRateCurve();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_EquityIndex_equityDividendCurve(void * jarg1) {
  void * jresult ;
  EquityIndex *arg1 = (EquityIndex *) 0 ;
  ext::shared_ptr< EquityIndex const > *smartarg1 = 0 ;
  Handle< YieldTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr< const EquityIndex > *)jarg1;
  arg1 = (EquityIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((EquityIndex const *)arg1)->equityDividendCurve();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_EquityIndex_spot(void * jarg1) {
  void * jresult ;
  EquityIndex *arg1 = (EquityIndex *) 0 ;
  ext::shared_ptr< EquityIndex const > *smartarg1 = 0 ;
  Handle< Quote > result;
  
  
  smartarg1 = (ext::shared_ptr< const EquityIndex > *)jarg1;
  arg1 = (EquityIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((EquityIndex const *)arg1)->spot();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_EquityIndex_clone(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  EquityIndex *arg1 = (EquityIndex *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  ext::shared_ptr< EquityIndex const > *smartarg1 = 0 ;
  ext::shared_ptr< EquityIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const EquityIndex > *)jarg1;
  arg1 = (EquityIndex *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((EquityIndex const *)arg1)->clone((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 = result ? new ext::shared_ptr< EquityIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EquityIndex(void * jarg1) {
  EquityIndex *arg1 = (EquityIndex *) 0 ;
  ext::shared_ptr< EquityIndex > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EquityIndex > *)jarg1;
  arg1 = (EquityIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  AUDLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AUDLibor *)new AUDLibor((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 = result ? new ext::shared_ptr<  AUDLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AUDLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  AUDLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AUDLibor *)new AUDLibor((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 = result ? new ext::shared_ptr<  AUDLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AUDLibor(void * jarg1) {
  AUDLibor *arg1 = (AUDLibor *) 0 ;
  ext::shared_ptr< AUDLibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AUDLibor > *)jarg1;
  arg1 = (AUDLibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  CADLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CADLibor *)new CADLibor((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 = result ? new ext::shared_ptr<  CADLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CADLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  CADLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CADLibor *)new CADLibor((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 = result ? new ext::shared_ptr<  CADLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CADLibor(void * jarg1) {
  CADLibor *arg1 = (CADLibor *) 0 ;
  ext::shared_ptr< CADLibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CADLibor > *)jarg1;
  arg1 = (CADLibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CADLiborON__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  CADLiborON *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CADLiborON *)new CADLiborON((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 = result ? new ext::shared_ptr<  CADLiborON >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CADLiborON(void * jarg1) {
  CADLiborON *arg1 = (CADLiborON *) 0 ;
  ext::shared_ptr< CADLiborON > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CADLiborON > *)jarg1;
  arg1 = (CADLiborON *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Cdor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Cdor *)new Cdor((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 = result ? new ext::shared_ptr<  Cdor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Cdor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  Cdor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Cdor *)new Cdor((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 = result ? new ext::shared_ptr<  Cdor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Cdor(void * jarg1) {
  Cdor *arg1 = (Cdor *) 0 ;
  ext::shared_ptr< Cdor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Cdor > *)jarg1;
  arg1 = (Cdor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  CHFLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CHFLibor *)new CHFLibor((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 = result ? new ext::shared_ptr<  CHFLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CHFLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  CHFLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CHFLibor *)new CHFLibor((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 = result ? new ext::shared_ptr<  CHFLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CHFLibor(void * jarg1) {
  CHFLibor *arg1 = (CHFLibor *) 0 ;
  ext::shared_ptr< CHFLibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CHFLibor > *)jarg1;
  arg1 = (CHFLibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  DKKLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DKKLibor *)new DKKLibor((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 = result ? new ext::shared_ptr<  DKKLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DKKLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  DKKLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DKKLibor *)new DKKLibor((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 = result ? new ext::shared_ptr<  DKKLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DKKLibor(void * jarg1) {
  DKKLibor *arg1 = (DKKLibor *) 0 ;
  ext::shared_ptr< DKKLibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DKKLibor > *)jarg1;
  arg1 = (DKKLibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Bbsw *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bbsw *)new Bbsw((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 = result ? new ext::shared_ptr<  Bbsw >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bbsw__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  Bbsw *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bbsw *)new Bbsw((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 = result ? new ext::shared_ptr<  Bbsw >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bbsw(void * jarg1) {
  Bbsw *arg1 = (Bbsw *) 0 ;
  ext::shared_ptr< Bbsw > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bbsw > *)jarg1;
  arg1 = (Bbsw *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Bbsw1M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bbsw1M *)new Bbsw1M((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 = result ? new ext::shared_ptr<  Bbsw1M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bbsw1M(void * jarg1) {
  Bbsw1M *arg1 = (Bbsw1M *) 0 ;
  ext::shared_ptr< Bbsw1M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bbsw1M > *)jarg1;
  arg1 = (Bbsw1M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Bbsw2M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bbsw2M *)new Bbsw2M((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 = result ? new ext::shared_ptr<  Bbsw2M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bbsw2M(void * jarg1) {
  Bbsw2M *arg1 = (Bbsw2M *) 0 ;
  ext::shared_ptr< Bbsw2M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bbsw2M > *)jarg1;
  arg1 = (Bbsw2M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Bbsw3M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bbsw3M *)new Bbsw3M((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 = result ? new ext::shared_ptr<  Bbsw3M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bbsw3M(void * jarg1) {
  Bbsw3M *arg1 = (Bbsw3M *) 0 ;
  ext::shared_ptr< Bbsw3M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bbsw3M > *)jarg1;
  arg1 = (Bbsw3M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Bbsw4M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bbsw4M *)new Bbsw4M((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 = result ? new ext::shared_ptr<  Bbsw4M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bbsw4M(void * jarg1) {
  Bbsw4M *arg1 = (Bbsw4M *) 0 ;
  ext::shared_ptr< Bbsw4M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bbsw4M > *)jarg1;
  arg1 = (Bbsw4M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Bbsw5M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bbsw5M *)new Bbsw5M((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 = result ? new ext::shared_ptr<  Bbsw5M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bbsw5M(void * jarg1) {
  Bbsw5M *arg1 = (Bbsw5M *) 0 ;
  ext::shared_ptr< Bbsw5M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bbsw5M > *)jarg1;
  arg1 = (Bbsw5M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Bbsw6M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bbsw6M *)new Bbsw6M((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 = result ? new ext::shared_ptr<  Bbsw6M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bbsw6M(void * jarg1) {
  Bbsw6M *arg1 = (Bbsw6M *) 0 ;
  ext::shared_ptr< Bbsw6M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bbsw6M > *)jarg1;
  arg1 = (Bbsw6M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Bkbm *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bkbm *)new Bkbm((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 = result ? new ext::shared_ptr<  Bkbm >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bkbm__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  Bkbm *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bkbm *)new Bkbm((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 = result ? new ext::shared_ptr<  Bkbm >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bkbm(void * jarg1) {
  Bkbm *arg1 = (Bkbm *) 0 ;
  ext::shared_ptr< Bkbm > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bkbm > *)jarg1;
  arg1 = (Bkbm *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Bkbm1M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bkbm1M *)new Bkbm1M((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 = result ? new ext::shared_ptr<  Bkbm1M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bkbm1M(void * jarg1) {
  Bkbm1M *arg1 = (Bkbm1M *) 0 ;
  ext::shared_ptr< Bkbm1M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bkbm1M > *)jarg1;
  arg1 = (Bkbm1M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Bkbm2M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bkbm2M *)new Bkbm2M((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 = result ? new ext::shared_ptr<  Bkbm2M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bkbm2M(void * jarg1) {
  Bkbm2M *arg1 = (Bkbm2M *) 0 ;
  ext::shared_ptr< Bkbm2M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bkbm2M > *)jarg1;
  arg1 = (Bkbm2M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Bkbm3M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bkbm3M *)new Bkbm3M((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 = result ? new ext::shared_ptr<  Bkbm3M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bkbm3M(void * jarg1) {
  Bkbm3M *arg1 = (Bkbm3M *) 0 ;
  ext::shared_ptr< Bkbm3M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bkbm3M > *)jarg1;
  arg1 = (Bkbm3M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Bkbm4M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bkbm4M *)new Bkbm4M((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 = result ? new ext::shared_ptr<  Bkbm4M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bkbm4M(void * jarg1) {
  Bkbm4M *arg1 = (Bkbm4M *) 0 ;
  ext::shared_ptr< Bkbm4M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bkbm4M > *)jarg1;
  arg1 = (Bkbm4M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Bkbm5M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bkbm5M *)new Bkbm5M((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 = result ? new ext::shared_ptr<  Bkbm5M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bkbm5M(void * jarg1) {
  Bkbm5M *arg1 = (Bkbm5M *) 0 ;
  ext::shared_ptr< Bkbm5M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bkbm5M > *)jarg1;
  arg1 = (Bkbm5M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Bkbm6M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bkbm6M *)new Bkbm6M((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 = result ? new ext::shared_ptr<  Bkbm6M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bkbm6M(void * jarg1) {
  Bkbm6M *arg1 = (Bkbm6M *) 0 ;
  ext::shared_ptr< Bkbm6M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bkbm6M > *)jarg1;
  arg1 = (Bkbm6M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Euribor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor *)new Euribor((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 = result ? new ext::shared_ptr<  Euribor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  Euribor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor *)new Euribor((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 = result ? new ext::shared_ptr<  Euribor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor(void * jarg1) {
  Euribor *arg1 = (Euribor *) 0 ;
  ext::shared_ptr< Euribor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor > *)jarg1;
  arg1 = (Euribor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EuriborSW *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSW *)new EuriborSW((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 = result ? new ext::shared_ptr<  EuriborSW >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EuriborSW(void * jarg1) {
  EuriborSW *arg1 = (EuriborSW *) 0 ;
  ext::shared_ptr< EuriborSW > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EuriborSW > *)jarg1;
  arg1 = (EuriborSW *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Euribor2W *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor2W *)new Euribor2W((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 = result ? new ext::shared_ptr<  Euribor2W >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor2W(void * jarg1) {
  Euribor2W *arg1 = (Euribor2W *) 0 ;
  ext::shared_ptr< Euribor2W > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor2W > *)jarg1;
  arg1 = (Euribor2W *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Euribor3W *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor3W *)new Euribor3W((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 = result ? new ext::shared_ptr<  Euribor3W >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor3W(void * jarg1) {
  Euribor3W *arg1 = (Euribor3W *) 0 ;
  ext::shared_ptr< Euribor3W > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor3W > *)jarg1;
  arg1 = (Euribor3W *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Euribor1M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor1M *)new Euribor1M((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 = result ? new ext::shared_ptr<  Euribor1M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor1M(void * jarg1) {
  Euribor1M *arg1 = (Euribor1M *) 0 ;
  ext::shared_ptr< Euribor1M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor1M > *)jarg1;
  arg1 = (Euribor1M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Euribor2M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor2M *)new Euribor2M((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 = result ? new ext::shared_ptr<  Euribor2M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor2M(void * jarg1) {
  Euribor2M *arg1 = (Euribor2M *) 0 ;
  ext::shared_ptr< Euribor2M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor2M > *)jarg1;
  arg1 = (Euribor2M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Euribor3M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor3M *)new Euribor3M((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 = result ? new ext::shared_ptr<  Euribor3M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor3M(void * jarg1) {
  Euribor3M *arg1 = (Euribor3M *) 0 ;
  ext::shared_ptr< Euribor3M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor3M > *)jarg1;
  arg1 = (Euribor3M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Euribor4M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor4M *)new Euribor4M((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 = result ? new ext::shared_ptr<  Euribor4M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor4M(void * jarg1) {
  Euribor4M *arg1 = (Euribor4M *) 0 ;
  ext::shared_ptr< Euribor4M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor4M > *)jarg1;
  arg1 = (Euribor4M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Euribor5M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor5M *)new Euribor5M((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 = result ? new ext::shared_ptr<  Euribor5M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor5M(void * jarg1) {
  Euribor5M *arg1 = (Euribor5M *) 0 ;
  ext::shared_ptr< Euribor5M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor5M > *)jarg1;
  arg1 = (Euribor5M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Euribor6M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor6M *)new Euribor6M((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 = result ? new ext::shared_ptr<  Euribor6M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor6M(void * jarg1) {
  Euribor6M *arg1 = (Euribor6M *) 0 ;
  ext::shared_ptr< Euribor6M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor6M > *)jarg1;
  arg1 = (Euribor6M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Euribor7M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor7M *)new Euribor7M((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 = result ? new ext::shared_ptr<  Euribor7M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor7M(void * jarg1) {
  Euribor7M *arg1 = (Euribor7M *) 0 ;
  ext::shared_ptr< Euribor7M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor7M > *)jarg1;
  arg1 = (Euribor7M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Euribor8M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor8M *)new Euribor8M((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 = result ? new ext::shared_ptr<  Euribor8M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor8M(void * jarg1) {
  Euribor8M *arg1 = (Euribor8M *) 0 ;
  ext::shared_ptr< Euribor8M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor8M > *)jarg1;
  arg1 = (Euribor8M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Euribor9M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor9M *)new Euribor9M((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 = result ? new ext::shared_ptr<  Euribor9M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor9M(void * jarg1) {
  Euribor9M *arg1 = (Euribor9M *) 0 ;
  ext::shared_ptr< Euribor9M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor9M > *)jarg1;
  arg1 = (Euribor9M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Euribor10M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor10M *)new Euribor10M((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 = result ? new ext::shared_ptr<  Euribor10M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor10M(void * jarg1) {
  Euribor10M *arg1 = (Euribor10M *) 0 ;
  ext::shared_ptr< Euribor10M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor10M > *)jarg1;
  arg1 = (Euribor10M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Euribor11M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor11M *)new Euribor11M((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 = result ? new ext::shared_ptr<  Euribor11M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor11M(void * jarg1) {
  Euribor11M *arg1 = (Euribor11M *) 0 ;
  ext::shared_ptr< Euribor11M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor11M > *)jarg1;
  arg1 = (Euribor11M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Euribor1Y *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor1Y *)new Euribor1Y((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 = result ? new ext::shared_ptr<  Euribor1Y >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor1Y(void * jarg1) {
  Euribor1Y *arg1 = (Euribor1Y *) 0 ;
  ext::shared_ptr< Euribor1Y > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor1Y > *)jarg1;
  arg1 = (Euribor1Y *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Euribor365 *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365 *)new Euribor365((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 = result ? new ext::shared_ptr<  Euribor365 >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Euribor365__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  Euribor365 *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365 *)new Euribor365((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 = result ? new ext::shared_ptr<  Euribor365 >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365(void * jarg1) {
  Euribor365 *arg1 = (Euribor365 *) 0 ;
  ext::shared_ptr< Euribor365 > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor365 > *)jarg1;
  arg1 = (Euribor365 *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_SW *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_SW *)new Euribor365_SW((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 = result ? new ext::shared_ptr<  Euribor365_SW >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_SW(void * jarg1) {
  Euribor365_SW *arg1 = (Euribor365_SW *) 0 ;
  ext::shared_ptr< Euribor365_SW > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor365_SW > *)jarg1;
  arg1 = (Euribor365_SW *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_2W *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_2W *)new Euribor365_2W((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 = result ? new ext::shared_ptr<  Euribor365_2W >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_2W(void * jarg1) {
  Euribor365_2W *arg1 = (Euribor365_2W *) 0 ;
  ext::shared_ptr< Euribor365_2W > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor365_2W > *)jarg1;
  arg1 = (Euribor365_2W *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_3W *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_3W *)new Euribor365_3W((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 = result ? new ext::shared_ptr<  Euribor365_3W >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_3W(void * jarg1) {
  Euribor365_3W *arg1 = (Euribor365_3W *) 0 ;
  ext::shared_ptr< Euribor365_3W > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor365_3W > *)jarg1;
  arg1 = (Euribor365_3W *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_1M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_1M *)new Euribor365_1M((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 = result ? new ext::shared_ptr<  Euribor365_1M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_1M(void * jarg1) {
  Euribor365_1M *arg1 = (Euribor365_1M *) 0 ;
  ext::shared_ptr< Euribor365_1M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor365_1M > *)jarg1;
  arg1 = (Euribor365_1M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_2M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_2M *)new Euribor365_2M((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 = result ? new ext::shared_ptr<  Euribor365_2M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_2M(void * jarg1) {
  Euribor365_2M *arg1 = (Euribor365_2M *) 0 ;
  ext::shared_ptr< Euribor365_2M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor365_2M > *)jarg1;
  arg1 = (Euribor365_2M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_3M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_3M *)new Euribor365_3M((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 = result ? new ext::shared_ptr<  Euribor365_3M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_3M(void * jarg1) {
  Euribor365_3M *arg1 = (Euribor365_3M *) 0 ;
  ext::shared_ptr< Euribor365_3M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor365_3M > *)jarg1;
  arg1 = (Euribor365_3M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_4M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_4M *)new Euribor365_4M((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 = result ? new ext::shared_ptr<  Euribor365_4M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_4M(void * jarg1) {
  Euribor365_4M *arg1 = (Euribor365_4M *) 0 ;
  ext::shared_ptr< Euribor365_4M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor365_4M > *)jarg1;
  arg1 = (Euribor365_4M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_5M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_5M *)new Euribor365_5M((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 = result ? new ext::shared_ptr<  Euribor365_5M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_5M(void * jarg1) {
  Euribor365_5M *arg1 = (Euribor365_5M *) 0 ;
  ext::shared_ptr< Euribor365_5M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor365_5M > *)jarg1;
  arg1 = (Euribor365_5M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_6M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_6M *)new Euribor365_6M((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 = result ? new ext::shared_ptr<  Euribor365_6M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_6M(void * jarg1) {
  Euribor365_6M *arg1 = (Euribor365_6M *) 0 ;
  ext::shared_ptr< Euribor365_6M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor365_6M > *)jarg1;
  arg1 = (Euribor365_6M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_7M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_7M *)new Euribor365_7M((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 = result ? new ext::shared_ptr<  Euribor365_7M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_7M(void * jarg1) {
  Euribor365_7M *arg1 = (Euribor365_7M *) 0 ;
  ext::shared_ptr< Euribor365_7M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor365_7M > *)jarg1;
  arg1 = (Euribor365_7M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_8M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_8M *)new Euribor365_8M((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 = result ? new ext::shared_ptr<  Euribor365_8M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_8M(void * jarg1) {
  Euribor365_8M *arg1 = (Euribor365_8M *) 0 ;
  ext::shared_ptr< Euribor365_8M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor365_8M > *)jarg1;
  arg1 = (Euribor365_8M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_9M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_9M *)new Euribor365_9M((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 = result ? new ext::shared_ptr<  Euribor365_9M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_9M(void * jarg1) {
  Euribor365_9M *arg1 = (Euribor365_9M *) 0 ;
  ext::shared_ptr< Euribor365_9M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor365_9M > *)jarg1;
  arg1 = (Euribor365_9M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_10M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_10M *)new Euribor365_10M((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 = result ? new ext::shared_ptr<  Euribor365_10M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_10M(void * jarg1) {
  Euribor365_10M *arg1 = (Euribor365_10M *) 0 ;
  ext::shared_ptr< Euribor365_10M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor365_10M > *)jarg1;
  arg1 = (Euribor365_10M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_11M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_11M *)new Euribor365_11M((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 = result ? new ext::shared_ptr<  Euribor365_11M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_11M(void * jarg1) {
  Euribor365_11M *arg1 = (Euribor365_11M *) 0 ;
  ext::shared_ptr< Euribor365_11M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor365_11M > *)jarg1;
  arg1 = (Euribor365_11M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_1Y *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Euribor365_1Y *)new Euribor365_1Y((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 = result ? new ext::shared_ptr<  Euribor365_1Y >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Euribor365_1Y(void * jarg1) {
  Euribor365_1Y *arg1 = (Euribor365_1Y *) 0 ;
  ext::shared_ptr< Euribor365_1Y > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Euribor365_1Y > *)jarg1;
  arg1 = (Euribor365_1Y *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EURLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor *)new EURLibor((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 = result ? new ext::shared_ptr<  EURLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EURLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  EURLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor *)new EURLibor((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 = result ? new ext::shared_ptr<  EURLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor(void * jarg1) {
  EURLibor *arg1 = (EURLibor *) 0 ;
  ext::shared_ptr< EURLibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EURLibor > *)jarg1;
  arg1 = (EURLibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EURLiborSW *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLiborSW *)new EURLiborSW((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 = result ? new ext::shared_ptr<  EURLiborSW >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLiborSW(void * jarg1) {
  EURLiborSW *arg1 = (EURLiborSW *) 0 ;
  ext::shared_ptr< EURLiborSW > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EURLiborSW > *)jarg1;
  arg1 = (EURLiborSW *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EURLibor2W *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor2W *)new EURLibor2W((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 = result ? new ext::shared_ptr<  EURLibor2W >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor2W(void * jarg1) {
  EURLibor2W *arg1 = (EURLibor2W *) 0 ;
  ext::shared_ptr< EURLibor2W > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EURLibor2W > *)jarg1;
  arg1 = (EURLibor2W *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EURLibor1M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor1M *)new EURLibor1M((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 = result ? new ext::shared_ptr<  EURLibor1M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor1M(void * jarg1) {
  EURLibor1M *arg1 = (EURLibor1M *) 0 ;
  ext::shared_ptr< EURLibor1M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EURLibor1M > *)jarg1;
  arg1 = (EURLibor1M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EURLibor2M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor2M *)new EURLibor2M((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 = result ? new ext::shared_ptr<  EURLibor2M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor2M(void * jarg1) {
  EURLibor2M *arg1 = (EURLibor2M *) 0 ;
  ext::shared_ptr< EURLibor2M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EURLibor2M > *)jarg1;
  arg1 = (EURLibor2M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EURLibor3M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor3M *)new EURLibor3M((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 = result ? new ext::shared_ptr<  EURLibor3M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor3M(void * jarg1) {
  EURLibor3M *arg1 = (EURLibor3M *) 0 ;
  ext::shared_ptr< EURLibor3M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EURLibor3M > *)jarg1;
  arg1 = (EURLibor3M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EURLibor4M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor4M *)new EURLibor4M((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 = result ? new ext::shared_ptr<  EURLibor4M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor4M(void * jarg1) {
  EURLibor4M *arg1 = (EURLibor4M *) 0 ;
  ext::shared_ptr< EURLibor4M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EURLibor4M > *)jarg1;
  arg1 = (EURLibor4M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EURLibor5M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor5M *)new EURLibor5M((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 = result ? new ext::shared_ptr<  EURLibor5M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor5M(void * jarg1) {
  EURLibor5M *arg1 = (EURLibor5M *) 0 ;
  ext::shared_ptr< EURLibor5M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EURLibor5M > *)jarg1;
  arg1 = (EURLibor5M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EURLibor6M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor6M *)new EURLibor6M((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 = result ? new ext::shared_ptr<  EURLibor6M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor6M(void * jarg1) {
  EURLibor6M *arg1 = (EURLibor6M *) 0 ;
  ext::shared_ptr< EURLibor6M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EURLibor6M > *)jarg1;
  arg1 = (EURLibor6M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EURLibor7M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor7M *)new EURLibor7M((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 = result ? new ext::shared_ptr<  EURLibor7M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor7M(void * jarg1) {
  EURLibor7M *arg1 = (EURLibor7M *) 0 ;
  ext::shared_ptr< EURLibor7M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EURLibor7M > *)jarg1;
  arg1 = (EURLibor7M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EURLibor8M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor8M *)new EURLibor8M((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 = result ? new ext::shared_ptr<  EURLibor8M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor8M(void * jarg1) {
  EURLibor8M *arg1 = (EURLibor8M *) 0 ;
  ext::shared_ptr< EURLibor8M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EURLibor8M > *)jarg1;
  arg1 = (EURLibor8M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EURLibor9M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor9M *)new EURLibor9M((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 = result ? new ext::shared_ptr<  EURLibor9M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor9M(void * jarg1) {
  EURLibor9M *arg1 = (EURLibor9M *) 0 ;
  ext::shared_ptr< EURLibor9M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EURLibor9M > *)jarg1;
  arg1 = (EURLibor9M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EURLibor10M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor10M *)new EURLibor10M((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 = result ? new ext::shared_ptr<  EURLibor10M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor10M(void * jarg1) {
  EURLibor10M *arg1 = (EURLibor10M *) 0 ;
  ext::shared_ptr< EURLibor10M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EURLibor10M > *)jarg1;
  arg1 = (EURLibor10M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EURLibor11M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor11M *)new EURLibor11M((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 = result ? new ext::shared_ptr<  EURLibor11M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor11M(void * jarg1) {
  EURLibor11M *arg1 = (EURLibor11M *) 0 ;
  ext::shared_ptr< EURLibor11M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EURLibor11M > *)jarg1;
  arg1 = (EURLibor11M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EURLibor1Y *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EURLibor1Y *)new EURLibor1Y((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 = result ? new ext::shared_ptr<  EURLibor1Y >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EURLibor1Y(void * jarg1) {
  EURLibor1Y *arg1 = (EURLibor1Y *) 0 ;
  ext::shared_ptr< EURLibor1Y > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EURLibor1Y > *)jarg1;
  arg1 = (EURLibor1Y *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  GBPLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (GBPLibor *)new GBPLibor((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 = result ? new ext::shared_ptr<  GBPLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GBPLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  GBPLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (GBPLibor *)new GBPLibor((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 = result ? new ext::shared_ptr<  GBPLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GBPLibor(void * jarg1) {
  GBPLibor *arg1 = (GBPLibor *) 0 ;
  ext::shared_ptr< GBPLibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GBPLibor > *)jarg1;
  arg1 = (GBPLibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GBPLiborON__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  GBPLiborON *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (GBPLiborON *)new GBPLiborON((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 = result ? new ext::shared_ptr<  GBPLiborON >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GBPLiborON(void * jarg1) {
  GBPLiborON *arg1 = (GBPLiborON *) 0 ;
  ext::shared_ptr< GBPLiborON > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GBPLiborON > *)jarg1;
  arg1 = (GBPLiborON *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Jibar *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Jibar *)new Jibar((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 = result ? new ext::shared_ptr<  Jibar >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Jibar__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  Jibar *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Jibar *)new Jibar((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 = result ? new ext::shared_ptr<  Jibar >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Jibar(void * jarg1) {
  Jibar *arg1 = (Jibar *) 0 ;
  ext::shared_ptr< Jibar > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Jibar > *)jarg1;
  arg1 = (Jibar *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  JPYLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (JPYLibor *)new JPYLibor((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 = result ? new ext::shared_ptr<  JPYLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JPYLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  JPYLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (JPYLibor *)new JPYLibor((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 = result ? new ext::shared_ptr<  JPYLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_JPYLibor(void * jarg1) {
  JPYLibor *arg1 = (JPYLibor *) 0 ;
  ext::shared_ptr< JPYLibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  JPYLibor > *)jarg1;
  arg1 = (JPYLibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Mosprime__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Mosprime *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Mosprime *)new Mosprime((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 = result ? new ext::shared_ptr<  Mosprime >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Mosprime__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  Mosprime *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Mosprime *)new Mosprime((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 = result ? new ext::shared_ptr<  Mosprime >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Mosprime(void * jarg1) {
  Mosprime *arg1 = (Mosprime *) 0 ;
  ext::shared_ptr< Mosprime > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Mosprime > *)jarg1;
  arg1 = (Mosprime *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  NZDLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (NZDLibor *)new NZDLibor((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 = result ? new ext::shared_ptr<  NZDLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NZDLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  NZDLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (NZDLibor *)new NZDLibor((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 = result ? new ext::shared_ptr<  NZDLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NZDLibor(void * jarg1) {
  NZDLibor *arg1 = (NZDLibor *) 0 ;
  ext::shared_ptr< NZDLibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  NZDLibor > *)jarg1;
  arg1 = (NZDLibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Pribor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Pribor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Pribor *)new Pribor((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 = result ? new ext::shared_ptr<  Pribor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Pribor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  Pribor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Pribor *)new Pribor((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 = result ? new ext::shared_ptr<  Pribor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Pribor(void * jarg1) {
  Pribor *arg1 = (Pribor *) 0 ;
  ext::shared_ptr< Pribor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Pribor > *)jarg1;
  arg1 = (Pribor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Robor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Robor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Robor *)new Robor((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 = result ? new ext::shared_ptr<  Robor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Robor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  Robor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Robor *)new Robor((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 = result ? new ext::shared_ptr<  Robor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Robor(void * jarg1) {
  Robor *arg1 = (Robor *) 0 ;
  ext::shared_ptr< Robor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Robor > *)jarg1;
  arg1 = (Robor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  SEKLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SEKLibor *)new SEKLibor((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 = result ? new ext::shared_ptr<  SEKLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SEKLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  SEKLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SEKLibor *)new SEKLibor((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 = result ? new ext::shared_ptr<  SEKLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SEKLibor(void * jarg1) {
  SEKLibor *arg1 = (SEKLibor *) 0 ;
  ext::shared_ptr< SEKLibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SEKLibor > *)jarg1;
  arg1 = (SEKLibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Shibor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Shibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Shibor *)new Shibor((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 = result ? new ext::shared_ptr<  Shibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Shibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  Shibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Shibor *)new Shibor((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 = result ? new ext::shared_ptr<  Shibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Shibor(void * jarg1) {
  Shibor *arg1 = (Shibor *) 0 ;
  ext::shared_ptr< Shibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Shibor > *)jarg1;
  arg1 = (Shibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Tibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Tibor *)new Tibor((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 = result ? new ext::shared_ptr<  Tibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Tibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  Tibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Tibor *)new Tibor((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 = result ? new ext::shared_ptr<  Tibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Tibor(void * jarg1) {
  Tibor *arg1 = (Tibor *) 0 ;
  ext::shared_ptr< Tibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Tibor > *)jarg1;
  arg1 = (Tibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_THBFIX__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  THBFIX *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (THBFIX *)new THBFIX((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 = result ? new ext::shared_ptr<  THBFIX >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_THBFIX__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  THBFIX *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (THBFIX *)new THBFIX((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 = result ? new ext::shared_ptr<  THBFIX >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_THBFIX(void * jarg1) {
  THBFIX *arg1 = (THBFIX *) 0 ;
  ext::shared_ptr< THBFIX > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  THBFIX > *)jarg1;
  arg1 = (THBFIX *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  TRLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (TRLibor *)new TRLibor((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 = result ? new ext::shared_ptr<  TRLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TRLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  TRLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (TRLibor *)new TRLibor((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 = result ? new ext::shared_ptr<  TRLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TRLibor(void * jarg1) {
  TRLibor *arg1 = (TRLibor *) 0 ;
  ext::shared_ptr< TRLibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  TRLibor > *)jarg1;
  arg1 = (TRLibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  USDLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (USDLibor *)new USDLibor((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 = result ? new ext::shared_ptr<  USDLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_USDLibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  USDLibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (USDLibor *)new USDLibor((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 = result ? new ext::shared_ptr<  USDLibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_USDLibor(void * jarg1) {
  USDLibor *arg1 = (USDLibor *) 0 ;
  ext::shared_ptr< USDLibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  USDLibor > *)jarg1;
  arg1 = (USDLibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_USDLiborON__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  USDLiborON *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (USDLiborON *)new USDLiborON((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 = result ? new ext::shared_ptr<  USDLiborON >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_USDLiborON(void * jarg1) {
  USDLiborON *arg1 = (USDLiborON *) 0 ;
  ext::shared_ptr< USDLiborON > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  USDLiborON > *)jarg1;
  arg1 = (USDLiborON *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Wibor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Wibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Wibor *)new Wibor((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 = result ? new ext::shared_ptr<  Wibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Wibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  Wibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Wibor *)new Wibor((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 = result ? new ext::shared_ptr<  Wibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Wibor(void * jarg1) {
  Wibor *arg1 = (Wibor *) 0 ;
  ext::shared_ptr< Wibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Wibor > *)jarg1;
  arg1 = (Wibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Zibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Zibor *)new Zibor((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 = result ? new ext::shared_ptr<  Zibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Zibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  Zibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Zibor *)new Zibor((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 = result ? new ext::shared_ptr<  Zibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Zibor(void * jarg1) {
  Zibor *arg1 = (Zibor *) 0 ;
  ext::shared_ptr< Zibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Zibor > *)jarg1;
  arg1 = (Zibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Aonia *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Aonia *)new Aonia((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 = result ? new ext::shared_ptr<  Aonia >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Aonia(void * jarg1) {
  Aonia *arg1 = (Aonia *) 0 ;
  ext::shared_ptr< Aonia > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Aonia > *)jarg1;
  arg1 = (Aonia *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Corra__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Corra *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Corra *)new Corra((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 = result ? new ext::shared_ptr<  Corra >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Corra(void * jarg1) {
  Corra *arg1 = (Corra *) 0 ;
  ext::shared_ptr< Corra > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Corra > *)jarg1;
  arg1 = (Corra *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Destr__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Destr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Destr *)new Destr((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 = result ? new ext::shared_ptr<  Destr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Destr(void * jarg1) {
  Destr *arg1 = (Destr *) 0 ;
  ext::shared_ptr< Destr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Destr > *)jarg1;
  arg1 = (Destr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Eonia *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Eonia *)new Eonia((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 = result ? new ext::shared_ptr<  Eonia >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Eonia(void * jarg1) {
  Eonia *arg1 = (Eonia *) 0 ;
  ext::shared_ptr< Eonia > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Eonia > *)jarg1;
  arg1 = (Eonia *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Estr__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Estr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Estr *)new Estr((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 = result ? new ext::shared_ptr<  Estr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Estr(void * jarg1) {
  Estr *arg1 = (Estr *) 0 ;
  ext::shared_ptr< Estr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Estr > *)jarg1;
  arg1 = (Estr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  FedFunds *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FedFunds *)new FedFunds((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 = result ? new ext::shared_ptr<  FedFunds >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FedFunds(void * jarg1) {
  FedFunds *arg1 = (FedFunds *) 0 ;
  ext::shared_ptr< FedFunds > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FedFunds > *)jarg1;
  arg1 = (FedFunds *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Nzocr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Nzocr *)new Nzocr((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 = result ? new ext::shared_ptr<  Nzocr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Nzocr(void * jarg1) {
  Nzocr *arg1 = (Nzocr *) 0 ;
  ext::shared_ptr< Nzocr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Nzocr > *)jarg1;
  arg1 = (Nzocr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Sofr__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Sofr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Sofr *)new Sofr((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 = result ? new ext::shared_ptr<  Sofr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Sofr(void * jarg1) {
  Sofr *arg1 = (Sofr *) 0 ;
  ext::shared_ptr< Sofr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Sofr > *)jarg1;
  arg1 = (Sofr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Sonia *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Sonia *)new Sonia((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 = result ? new ext::shared_ptr<  Sonia >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Sonia(void * jarg1) {
  Sonia *arg1 = (Sonia *) 0 ;
  ext::shared_ptr< Sonia > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Sonia > *)jarg1;
  arg1 = (Sonia *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Swestr__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Swestr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Swestr *)new Swestr((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 = result ? new ext::shared_ptr<  Swestr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Swestr(void * jarg1) {
  Swestr *arg1 = (Swestr *) 0 ;
  ext::shared_ptr< Swestr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Swestr > *)jarg1;
  arg1 = (Swestr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EuriborSwapIsdaFixA *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIsdaFixA *)new EuriborSwapIsdaFixA((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 = result ? new ext::shared_ptr<  EuriborSwapIsdaFixA >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuriborSwapIsdaFixA__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  EuriborSwapIsdaFixA *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIsdaFixA *)new EuriborSwapIsdaFixA((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 = result ? new ext::shared_ptr<  EuriborSwapIsdaFixA >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  EuriborSwapIsdaFixA *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIsdaFixA *)new EuriborSwapIsdaFixA((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 = result ? new ext::shared_ptr<  EuriborSwapIsdaFixA >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EuriborSwapIsdaFixA(void * jarg1) {
  EuriborSwapIsdaFixA *arg1 = (EuriborSwapIsdaFixA *) 0 ;
  ext::shared_ptr< EuriborSwapIsdaFixA > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EuriborSwapIsdaFixA > *)jarg1;
  arg1 = (EuriborSwapIsdaFixA *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EuriborSwapIsdaFixB *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIsdaFixB *)new EuriborSwapIsdaFixB((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 = result ? new ext::shared_ptr<  EuriborSwapIsdaFixB >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuriborSwapIsdaFixB__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  EuriborSwapIsdaFixB *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIsdaFixB *)new EuriborSwapIsdaFixB((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 = result ? new ext::shared_ptr<  EuriborSwapIsdaFixB >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  EuriborSwapIsdaFixB *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIsdaFixB *)new EuriborSwapIsdaFixB((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 = result ? new ext::shared_ptr<  EuriborSwapIsdaFixB >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EuriborSwapIsdaFixB(void * jarg1) {
  EuriborSwapIsdaFixB *arg1 = (EuriborSwapIsdaFixB *) 0 ;
  ext::shared_ptr< EuriborSwapIsdaFixB > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EuriborSwapIsdaFixB > *)jarg1;
  arg1 = (EuriborSwapIsdaFixB *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EuriborSwapIfrFix *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIfrFix *)new EuriborSwapIfrFix((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 = result ? new ext::shared_ptr<  EuriborSwapIfrFix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuriborSwapIfrFix__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  EuriborSwapIfrFix *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIfrFix *)new EuriborSwapIfrFix((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 = result ? new ext::shared_ptr<  EuriborSwapIfrFix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  EuriborSwapIfrFix *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuriborSwapIfrFix *)new EuriborSwapIfrFix((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 = result ? new ext::shared_ptr<  EuriborSwapIfrFix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EuriborSwapIfrFix(void * jarg1) {
  EuriborSwapIfrFix *arg1 = (EuriborSwapIfrFix *) 0 ;
  ext::shared_ptr< EuriborSwapIfrFix > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EuriborSwapIfrFix > *)jarg1;
  arg1 = (EuriborSwapIfrFix *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EurLiborSwapIsdaFixA *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIsdaFixA *)new EurLiborSwapIsdaFixA((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 = result ? new ext::shared_ptr<  EurLiborSwapIsdaFixA >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EurLiborSwapIsdaFixA__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  EurLiborSwapIsdaFixA *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIsdaFixA *)new EurLiborSwapIsdaFixA((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 = result ? new ext::shared_ptr<  EurLiborSwapIsdaFixA >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  EurLiborSwapIsdaFixA *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIsdaFixA *)new EurLiborSwapIsdaFixA((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 = result ? new ext::shared_ptr<  EurLiborSwapIsdaFixA >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EurLiborSwapIsdaFixA(void * jarg1) {
  EurLiborSwapIsdaFixA *arg1 = (EurLiborSwapIsdaFixA *) 0 ;
  ext::shared_ptr< EurLiborSwapIsdaFixA > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EurLiborSwapIsdaFixA > *)jarg1;
  arg1 = (EurLiborSwapIsdaFixA *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EurLiborSwapIsdaFixB *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIsdaFixB *)new EurLiborSwapIsdaFixB((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 = result ? new ext::shared_ptr<  EurLiborSwapIsdaFixB >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EurLiborSwapIsdaFixB__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  EurLiborSwapIsdaFixB *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIsdaFixB *)new EurLiborSwapIsdaFixB((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 = result ? new ext::shared_ptr<  EurLiborSwapIsdaFixB >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  EurLiborSwapIsdaFixB *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIsdaFixB *)new EurLiborSwapIsdaFixB((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 = result ? new ext::shared_ptr<  EurLiborSwapIsdaFixB >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EurLiborSwapIsdaFixB(void * jarg1) {
  EurLiborSwapIsdaFixB *arg1 = (EurLiborSwapIsdaFixB *) 0 ;
  ext::shared_ptr< EurLiborSwapIsdaFixB > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EurLiborSwapIsdaFixB > *)jarg1;
  arg1 = (EurLiborSwapIsdaFixB *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  EurLiborSwapIfrFix *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIfrFix *)new EurLiborSwapIfrFix((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 = result ? new ext::shared_ptr<  EurLiborSwapIfrFix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EurLiborSwapIfrFix__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  EurLiborSwapIfrFix *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIfrFix *)new EurLiborSwapIfrFix((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 = result ? new ext::shared_ptr<  EurLiborSwapIfrFix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  EurLiborSwapIfrFix *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EurLiborSwapIfrFix *)new EurLiborSwapIfrFix((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 = result ? new ext::shared_ptr<  EurLiborSwapIfrFix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EurLiborSwapIfrFix(void * jarg1) {
  EurLiborSwapIfrFix *arg1 = (EurLiborSwapIfrFix *) 0 ;
  ext::shared_ptr< EurLiborSwapIfrFix > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EurLiborSwapIfrFix > *)jarg1;
  arg1 = (EurLiborSwapIfrFix *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ChfLiborSwapIsdaFix__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  ChfLiborSwapIsdaFix *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ChfLiborSwapIsdaFix *)new ChfLiborSwapIsdaFix((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 = result ? new ext::shared_ptr<  ChfLiborSwapIsdaFix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ChfLiborSwapIsdaFix__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  ChfLiborSwapIsdaFix *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ChfLiborSwapIsdaFix *)new ChfLiborSwapIsdaFix((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 = result ? new ext::shared_ptr<  ChfLiborSwapIsdaFix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ChfLiborSwapIsdaFix__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  ChfLiborSwapIsdaFix *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ChfLiborSwapIsdaFix *)new ChfLiborSwapIsdaFix((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 = result ? new ext::shared_ptr<  ChfLiborSwapIsdaFix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ChfLiborSwapIsdaFix(void * jarg1) {
  ChfLiborSwapIsdaFix *arg1 = (ChfLiborSwapIsdaFix *) 0 ;
  ext::shared_ptr< ChfLiborSwapIsdaFix > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ChfLiborSwapIsdaFix > *)jarg1;
  arg1 = (ChfLiborSwapIsdaFix *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GbpLiborSwapIsdaFix__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  GbpLiborSwapIsdaFix *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (GbpLiborSwapIsdaFix *)new GbpLiborSwapIsdaFix((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 = result ? new ext::shared_ptr<  GbpLiborSwapIsdaFix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GbpLiborSwapIsdaFix__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  GbpLiborSwapIsdaFix *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (GbpLiborSwapIsdaFix *)new GbpLiborSwapIsdaFix((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 = result ? new ext::shared_ptr<  GbpLiborSwapIsdaFix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GbpLiborSwapIsdaFix__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  GbpLiborSwapIsdaFix *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (GbpLiborSwapIsdaFix *)new GbpLiborSwapIsdaFix((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 = result ? new ext::shared_ptr<  GbpLiborSwapIsdaFix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GbpLiborSwapIsdaFix(void * jarg1) {
  GbpLiborSwapIsdaFix *arg1 = (GbpLiborSwapIsdaFix *) 0 ;
  ext::shared_ptr< GbpLiborSwapIsdaFix > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GbpLiborSwapIsdaFix > *)jarg1;
  arg1 = (GbpLiborSwapIsdaFix *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JpyLiborSwapIsdaFixAm__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  JpyLiborSwapIsdaFixAm *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (JpyLiborSwapIsdaFixAm *)new JpyLiborSwapIsdaFixAm((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 = result ? new ext::shared_ptr<  JpyLiborSwapIsdaFixAm >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JpyLiborSwapIsdaFixAm__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  JpyLiborSwapIsdaFixAm *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (JpyLiborSwapIsdaFixAm *)new JpyLiborSwapIsdaFixAm((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 = result ? new ext::shared_ptr<  JpyLiborSwapIsdaFixAm >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JpyLiborSwapIsdaFixAm__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  JpyLiborSwapIsdaFixAm *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (JpyLiborSwapIsdaFixAm *)new JpyLiborSwapIsdaFixAm((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 = result ? new ext::shared_ptr<  JpyLiborSwapIsdaFixAm >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_JpyLiborSwapIsdaFixAm(void * jarg1) {
  JpyLiborSwapIsdaFixAm *arg1 = (JpyLiborSwapIsdaFixAm *) 0 ;
  ext::shared_ptr< JpyLiborSwapIsdaFixAm > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  JpyLiborSwapIsdaFixAm > *)jarg1;
  arg1 = (JpyLiborSwapIsdaFixAm *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JpyLiborSwapIsdaFixPm__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  JpyLiborSwapIsdaFixPm *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (JpyLiborSwapIsdaFixPm *)new JpyLiborSwapIsdaFixPm((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 = result ? new ext::shared_ptr<  JpyLiborSwapIsdaFixPm >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JpyLiborSwapIsdaFixPm__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  JpyLiborSwapIsdaFixPm *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (JpyLiborSwapIsdaFixPm *)new JpyLiborSwapIsdaFixPm((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 = result ? new ext::shared_ptr<  JpyLiborSwapIsdaFixPm >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JpyLiborSwapIsdaFixPm__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  JpyLiborSwapIsdaFixPm *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (JpyLiborSwapIsdaFixPm *)new JpyLiborSwapIsdaFixPm((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 = result ? new ext::shared_ptr<  JpyLiborSwapIsdaFixPm >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_JpyLiborSwapIsdaFixPm(void * jarg1) {
  JpyLiborSwapIsdaFixPm *arg1 = (JpyLiborSwapIsdaFixPm *) 0 ;
  ext::shared_ptr< JpyLiborSwapIsdaFixPm > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  JpyLiborSwapIsdaFixPm > *)jarg1;
  arg1 = (JpyLiborSwapIsdaFixPm *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UsdLiborSwapIsdaFixAm__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  UsdLiborSwapIsdaFixAm *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (UsdLiborSwapIsdaFixAm *)new UsdLiborSwapIsdaFixAm((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 = result ? new ext::shared_ptr<  UsdLiborSwapIsdaFixAm >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UsdLiborSwapIsdaFixAm__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  UsdLiborSwapIsdaFixAm *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (UsdLiborSwapIsdaFixAm *)new UsdLiborSwapIsdaFixAm((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 = result ? new ext::shared_ptr<  UsdLiborSwapIsdaFixAm >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UsdLiborSwapIsdaFixAm__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  UsdLiborSwapIsdaFixAm *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (UsdLiborSwapIsdaFixAm *)new UsdLiborSwapIsdaFixAm((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 = result ? new ext::shared_ptr<  UsdLiborSwapIsdaFixAm >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UsdLiborSwapIsdaFixAm(void * jarg1) {
  UsdLiborSwapIsdaFixAm *arg1 = (UsdLiborSwapIsdaFixAm *) 0 ;
  ext::shared_ptr< UsdLiborSwapIsdaFixAm > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  UsdLiborSwapIsdaFixAm > *)jarg1;
  arg1 = (UsdLiborSwapIsdaFixAm *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UsdLiborSwapIsdaFixPm__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  UsdLiborSwapIsdaFixPm *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (UsdLiborSwapIsdaFixPm *)new UsdLiborSwapIsdaFixPm((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 = result ? new ext::shared_ptr<  UsdLiborSwapIsdaFixPm >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UsdLiborSwapIsdaFixPm__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  UsdLiborSwapIsdaFixPm *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (UsdLiborSwapIsdaFixPm *)new UsdLiborSwapIsdaFixPm((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 = result ? new ext::shared_ptr<  UsdLiborSwapIsdaFixPm >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UsdLiborSwapIsdaFixPm__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  UsdLiborSwapIsdaFixPm *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (UsdLiborSwapIsdaFixPm *)new UsdLiborSwapIsdaFixPm((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 = result ? new ext::shared_ptr<  UsdLiborSwapIsdaFixPm >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UsdLiborSwapIsdaFixPm(void * jarg1) {
  UsdLiborSwapIsdaFixPm *arg1 = (UsdLiborSwapIsdaFixPm *) 0 ;
  ext::shared_ptr< UsdLiborSwapIsdaFixPm > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  UsdLiborSwapIsdaFixPm > *)jarg1;
  arg1 = (UsdLiborSwapIsdaFixPm *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bibor__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Bibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bibor *)new Bibor((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 = result ? new ext::shared_ptr<  Bibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bibor__SWIG_1(void * jarg1) {
  void * jresult ;
  Period *arg1 = 0 ;
  Bibor *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bibor *)new Bibor((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 = result ? new ext::shared_ptr<  Bibor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bibor(void * jarg1) {
  Bibor *arg1 = (Bibor *) 0 ;
  ext::shared_ptr< Bibor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bibor > *)jarg1;
  arg1 = (Bibor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BiborSW__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  BiborSW *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BiborSW *)new BiborSW((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 = result ? new ext::shared_ptr<  BiborSW >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BiborSW(void * jarg1) {
  BiborSW *arg1 = (BiborSW *) 0 ;
  ext::shared_ptr< BiborSW > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BiborSW > *)jarg1;
  arg1 = (BiborSW *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bibor1M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bibor1M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bibor1M *)new Bibor1M((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 = result ? new ext::shared_ptr<  Bibor1M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bibor1M(void * jarg1) {
  Bibor1M *arg1 = (Bibor1M *) 0 ;
  ext::shared_ptr< Bibor1M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bibor1M > *)jarg1;
  arg1 = (Bibor1M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bibor2M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bibor2M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bibor2M *)new Bibor2M((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 = result ? new ext::shared_ptr<  Bibor2M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bibor2M(void * jarg1) {
  Bibor2M *arg1 = (Bibor2M *) 0 ;
  ext::shared_ptr< Bibor2M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bibor2M > *)jarg1;
  arg1 = (Bibor2M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bibor3M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bibor3M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bibor3M *)new Bibor3M((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 = result ? new ext::shared_ptr<  Bibor3M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bibor3M(void * jarg1) {
  Bibor3M *arg1 = (Bibor3M *) 0 ;
  ext::shared_ptr< Bibor3M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bibor3M > *)jarg1;
  arg1 = (Bibor3M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bibor6M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bibor6M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bibor6M *)new Bibor6M((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 = result ? new ext::shared_ptr<  Bibor6M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bibor6M(void * jarg1) {
  Bibor6M *arg1 = (Bibor6M *) 0 ;
  ext::shared_ptr< Bibor6M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bibor6M > *)jarg1;
  arg1 = (Bibor6M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bibor9M__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bibor9M *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bibor9M *)new Bibor9M((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 = result ? new ext::shared_ptr<  Bibor9M >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bibor9M(void * jarg1) {
  Bibor9M *arg1 = (Bibor9M *) 0 ;
  ext::shared_ptr< Bibor9M > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bibor9M > *)jarg1;
  arg1 = (Bibor9M *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bibor1Y__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Bibor1Y *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bibor1Y *)new Bibor1Y((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 = result ? new ext::shared_ptr<  Bibor1Y >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Bibor1Y(void * jarg1) {
  Bibor1Y *arg1 = (Bibor1Y *) 0 ;
  ext::shared_ptr< Bibor1Y > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bibor1Y > *)jarg1;
  arg1 = (Bibor1Y *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Schedule_previousDate(void * jarg1, void * jarg2) {
  void * jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  Date *arg2 = 0 ;
  Date result;
  
  arg1 = (Schedule *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((Schedule const *)arg1)->previousDate((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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Schedule_nextDate(void * jarg1, void * jarg2) {
  void * jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  Date *arg2 = 0 ;
  Date result;
  
  arg1 = (Schedule *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((Schedule const *)arg1)->nextDate((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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Schedule_dates(void * jarg1) {
  void * jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  std::vector< Date > *result = 0 ;
  
  arg1 = (Schedule *)jarg1; 
  {
    try {
      result = (std::vector< Date > *) &((Schedule 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 unsigned int SWIGSTDCALL CSharp_QuantLib_Schedule_hasIsRegular(void * jarg1) {
  unsigned int jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  bool result;
  
  arg1 = (Schedule *)jarg1; 
  {
    try {
      result = (bool)((Schedule const *)arg1)->hasIsRegular();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_Schedule_isRegular__SWIG_0(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_isRegular__SWIG_1(void * jarg1) {
  void * jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  std::vector< bool > *result = 0 ;
  
  arg1 = (Schedule *)jarg1; 
  {
    try {
      result = (std::vector< bool > *) &((Schedule const *)arg1)->isRegular();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Schedule_calendar(void * jarg1) {
  void * jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  Calendar *result = 0 ;
  
  arg1 = (Schedule *)jarg1; 
  {
    try {
      result = (Calendar *) &((Schedule const *)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 = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Schedule_endDate(void * jarg1) {
  void * jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  Date *result = 0 ;
  
  arg1 = (Schedule *)jarg1; 
  {
    try {
      result = (Date *) &((Schedule const *)arg1)->endDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_Schedule_hasTenor(void * jarg1) {
  unsigned int jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  bool result;
  
  arg1 = (Schedule *)jarg1; 
  {
    try {
      result = (bool)((Schedule const *)arg1)->hasTenor();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_tenor(void * jarg1) {
  void * jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  Period *result = 0 ;
  
  arg1 = (Schedule *)jarg1; 
  {
    try {
      result = (Period *) &((Schedule const *)arg1)->tenor();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_Schedule_businessDayConvention(void * jarg1) {
  int jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  BusinessDayConvention result;
  
  arg1 = (Schedule *)jarg1; 
  {
    try {
      result = (BusinessDayConvention)((Schedule const *)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 unsigned int SWIGSTDCALL CSharp_QuantLib_Schedule_hasTerminationDateBusinessDayConvention(void * jarg1) {
  unsigned int jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  bool result;
  
  arg1 = (Schedule *)jarg1; 
  {
    try {
      result = (bool)((Schedule const *)arg1)->hasTerminationDateBusinessDayConvention();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_Schedule_terminationDateBusinessDayConvention(void * jarg1) {
  int jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  BusinessDayConvention result;
  
  arg1 = (Schedule *)jarg1; 
  {
    try {
      result = (BusinessDayConvention)((Schedule const *)arg1)->terminationDateBusinessDayConvention();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_Schedule_hasRule(void * jarg1) {
  unsigned int jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  bool result;
  
  arg1 = (Schedule *)jarg1; 
  {
    try {
      result = (bool)((Schedule const *)arg1)->hasRule();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_Schedule_rule(void * jarg1) {
  int jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  DateGeneration::Rule result;
  
  arg1 = (Schedule *)jarg1; 
  {
    try {
      result = (DateGeneration::Rule)((Schedule const *)arg1)->rule();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_Schedule_hasEndOfMonth(void * jarg1) {
  unsigned int jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  bool result;
  
  arg1 = (Schedule *)jarg1; 
  {
    try {
      result = (bool)((Schedule const *)arg1)->hasEndOfMonth();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_Schedule_endOfMonth(void * jarg1) {
  unsigned int jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  bool result;
  
  arg1 = (Schedule *)jarg1; 
  {
    try {
      result = (bool)((Schedule const *)arg1)->endOfMonth();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_after(void * jarg1, void * jarg2) {
  void * jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  Date *arg2 = 0 ;
  Schedule result;
  
  arg1 = (Schedule *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((Schedule const *)arg1)->after((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 Schedule(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Schedule_until(void * jarg1, void * jarg2) {
  void * jresult ;
  Schedule *arg1 = (Schedule *) 0 ;
  Date *arg2 = 0 ;
  Schedule result;
  
  arg1 = (Schedule *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((Schedule const *)arg1)->until((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 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_new_MakeSchedule() {
  void * jresult ;
  MakeSchedule *result = 0 ;
  
  {
    try {
      result = (MakeSchedule *)new MakeSchedule();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeSchedule_from(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  Date *arg2 = 0 ;
  MakeSchedule *result = 0 ;
  
  arg1 = (MakeSchedule *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeSchedule *) &(arg1)->from((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_MakeSchedule_to(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  Date *arg2 = 0 ;
  MakeSchedule *result = 0 ;
  
  arg1 = (MakeSchedule *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeSchedule *) &(arg1)->to((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_MakeSchedule_withTenor(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  Period *arg2 = 0 ;
  MakeSchedule *result = 0 ;
  
  arg1 = (MakeSchedule *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeSchedule *) &(arg1)->withTenor((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 = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeSchedule_withCalendar(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  Calendar *arg2 = 0 ;
  MakeSchedule *result = 0 ;
  
  arg1 = (MakeSchedule *)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeSchedule *) &(arg1)->withCalendar((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_MakeSchedule_withConvention(void * jarg1, int jarg2) {
  void * jresult ;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  BusinessDayConvention arg2 ;
  MakeSchedule *result = 0 ;
  
  arg1 = (MakeSchedule *)jarg1; 
  arg2 = (BusinessDayConvention)jarg2; 
  {
    try {
      result = (MakeSchedule *) &(arg1)->withConvention(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeSchedule_withRule(void * jarg1, int jarg2) {
  void * jresult ;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  DateGeneration::Rule arg2 ;
  MakeSchedule *result = 0 ;
  
  arg1 = (MakeSchedule *)jarg1; 
  arg2 = (DateGeneration::Rule)jarg2; 
  {
    try {
      result = (MakeSchedule *) &(arg1)->withRule(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeSchedule_endOfMonth__SWIG_0(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  bool arg2 ;
  MakeSchedule *result = 0 ;
  
  arg1 = (MakeSchedule *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MakeSchedule *) &(arg1)->endOfMonth(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeSchedule_withFirstDate(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  Date *arg2 = 0 ;
  MakeSchedule *result = 0 ;
  
  arg1 = (MakeSchedule *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeSchedule *) &(arg1)->withFirstDate((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_MakeSchedule_withNextToLastDate(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  Date *arg2 = 0 ;
  MakeSchedule *result = 0 ;
  
  arg1 = (MakeSchedule *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeSchedule *) &(arg1)->withNextToLastDate((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_MakeSchedule_schedule(void * jarg1) {
  void * jresult ;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  Schedule result;
  
  arg1 = (MakeSchedule *)jarg1; 
  {
    try {
      result = MakeSchedule_schedule(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MakeSchedule(void * jarg1) {
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  
  arg1 = (MakeSchedule *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_VolatilityTermStructure_minStrike(void * jarg1) {
  double jresult ;
  VolatilityTermStructure *arg1 = (VolatilityTermStructure *) 0 ;
  ext::shared_ptr< VolatilityTermStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const VolatilityTermStructure > *)jarg1;
  arg1 = (VolatilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((VolatilityTermStructure const *)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_VolatilityTermStructure_maxStrike(void * jarg1) {
  double jresult ;
  VolatilityTermStructure *arg1 = (VolatilityTermStructure *) 0 ;
  ext::shared_ptr< VolatilityTermStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const VolatilityTermStructure > *)jarg1;
  arg1 = (VolatilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((VolatilityTermStructure const *)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 void SWIGSTDCALL CSharp_QuantLib_delete_VolatilityTermStructure(void * jarg1) {
  VolatilityTermStructure *arg1 = (VolatilityTermStructure *) 0 ;
  ext::shared_ptr< VolatilityTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  VolatilityTermStructure > *)jarg1;
  arg1 = (VolatilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_BlackVolTermStructure_blackVol__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)((BlackVolTermStructure const *)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 ;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)((BlackVolTermStructure const *)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 ;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)((BlackVolTermStructure const *)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 ;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Time arg2 ;
  Real arg3 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)((BlackVolTermStructure const *)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 ;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)((BlackVolTermStructure const *)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 ;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((BlackVolTermStructure const *)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 ;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)((BlackVolTermStructure const *)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 ;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Time arg2 ;
  Real arg3 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((BlackVolTermStructure const *)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 ;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  bool arg5 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Volatility)((BlackVolTermStructure const *)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 ;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Volatility)((BlackVolTermStructure const *)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 ;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  bool arg5 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Volatility)((BlackVolTermStructure const *)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 ;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Volatility)((BlackVolTermStructure const *)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 ;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  bool arg5 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Real)((BlackVolTermStructure const *)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 ;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)((BlackVolTermStructure const *)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 ;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  bool arg5 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Real)((BlackVolTermStructure const *)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 ;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)((BlackVolTermStructure const *)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_delete_BlackVolTermStructure(void * jarg1) {
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  ext::shared_ptr< BlackVolTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackVolTermStructure > *)jarg1;
  arg1 = (BlackVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackVolTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< BlackVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure > tempnull1 ;
  Handle< BlackVolTermStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BlackVolTermStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Handle< BlackVolTermStructure > *)new Handle< BlackVolTermStructure >((ext::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 ;
  ext::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 = result ? new ext::shared_ptr< BlackVolTermStructure >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_currentLink(void * jarg1) {
  void * jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  ext::shared_ptr< BlackVolTermStructure > result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< BlackVolTermStructure >(result) : 0; 
  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 ;
  ext::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 = result ? new ext::shared_ptr< Observable >(result) : 0; 
  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 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 & 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 & 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 & 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 & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 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 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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructureHandle_timeFromReference(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time result;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)(*arg1)->timeFromReference((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_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(result); 
  return jresult;
}


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(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(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 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 ;
  ext::shared_ptr< BlackVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure > tempnull1 ;
  RelinkableHandle< BlackVolTermStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BlackVolTermStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (RelinkableHandle< BlackVolTermStructure > *)new RelinkableHandle< BlackVolTermStructure >((ext::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 ;
  ext::shared_ptr< BlackVolTermStructure > *arg2 = 0 ;
  ext::shared_ptr< BlackVolTermStructure > tempnull2 ;
  
  arg1 = (RelinkableHandle< BlackVolTermStructure > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BlackVolTermStructure > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->linkTo((ext::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_RelinkableBlackVolTermStructureHandle_reset(void * jarg1) {
  RelinkableHandle< BlackVolTermStructure > *arg1 = (RelinkableHandle< BlackVolTermStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< BlackVolTermStructure > *)jarg1; 
  {
    try {
      RelinkableHandle_Sl_BlackVolTermStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 double SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_localVol__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  LocalVolTermStructure *arg1 = (LocalVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  ext::shared_ptr< LocalVolTermStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const LocalVolTermStructure > *)jarg1;
  arg1 = (LocalVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)((LocalVolTermStructure const *)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 ;
  LocalVolTermStructure *arg1 = (LocalVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< LocalVolTermStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const LocalVolTermStructure > *)jarg1;
  arg1 = (LocalVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)((LocalVolTermStructure const *)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 ;
  LocalVolTermStructure *arg1 = (LocalVolTermStructure *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  ext::shared_ptr< LocalVolTermStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const LocalVolTermStructure > *)jarg1;
  arg1 = (LocalVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)((LocalVolTermStructure const *)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 ;
  LocalVolTermStructure *arg1 = (LocalVolTermStructure *) 0 ;
  Time arg2 ;
  Real arg3 ;
  ext::shared_ptr< LocalVolTermStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const LocalVolTermStructure > *)jarg1;
  arg1 = (LocalVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)((LocalVolTermStructure const *)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_delete_LocalVolTermStructure(void * jarg1) {
  LocalVolTermStructure *arg1 = (LocalVolTermStructure *) 0 ;
  ext::shared_ptr< LocalVolTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  LocalVolTermStructure > *)jarg1;
  arg1 = (LocalVolTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalVolTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull1 ;
  Handle< LocalVolTermStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Handle< LocalVolTermStructure > *)new Handle< LocalVolTermStructure >((ext::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 ;
  ext::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 = result ? new ext::shared_ptr< LocalVolTermStructure >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_currentLink(void * jarg1) {
  void * jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  ext::shared_ptr< LocalVolTermStructure > result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< LocalVolTermStructure >(result) : 0; 
  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 ;
  ext::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 = result ? new ext::shared_ptr< Observable >(result) : 0; 
  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 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 & 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 & 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 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 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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructureHandle_timeFromReference(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time result;
  
  arg1 = (Handle< LocalVolTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)(*arg1)->timeFromReference((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_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(result); 
  return jresult;
}


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(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(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 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 ;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull1 ;
  RelinkableHandle< LocalVolTermStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (RelinkableHandle< LocalVolTermStructure > *)new RelinkableHandle< LocalVolTermStructure >((ext::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 ;
  ext::shared_ptr< LocalVolTermStructure > *arg2 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull2 ;
  
  arg1 = (RelinkableHandle< LocalVolTermStructure > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->linkTo((ext::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_RelinkableLocalVolTermStructureHandle_reset(void * jarg1) {
  RelinkableHandle< LocalVolTermStructure > *arg1 = (RelinkableHandle< LocalVolTermStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< LocalVolTermStructure > *)jarg1; 
  {
    try {
      RelinkableHandle_Sl_LocalVolTermStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_volatility__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  ext::shared_ptr< OptionletVolatilityStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const OptionletVolatilityStructure > *)jarg1;
  arg1 = (OptionletVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)((OptionletVolatilityStructure const *)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 ;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< OptionletVolatilityStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const OptionletVolatilityStructure > *)jarg1;
  arg1 = (OptionletVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)((OptionletVolatilityStructure const *)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 ;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  ext::shared_ptr< OptionletVolatilityStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const OptionletVolatilityStructure > *)jarg1;
  arg1 = (OptionletVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Volatility)((OptionletVolatilityStructure const *)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 ;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  Time arg2 ;
  Real arg3 ;
  ext::shared_ptr< OptionletVolatilityStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const OptionletVolatilityStructure > *)jarg1;
  arg1 = (OptionletVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)((OptionletVolatilityStructure const *)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 ;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  ext::shared_ptr< OptionletVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OptionletVolatilityStructure > *)jarg1;
  arg1 = (OptionletVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)((OptionletVolatilityStructure const *)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 ;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  ext::shared_ptr< OptionletVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OptionletVolatilityStructure > *)jarg1;
  arg1 = (OptionletVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Real)((OptionletVolatilityStructure const *)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 ;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  bool arg4 ;
  ext::shared_ptr< OptionletVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OptionletVolatilityStructure > *)jarg1;
  arg1 = (OptionletVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)((OptionletVolatilityStructure const *)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 ;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  ext::shared_ptr< OptionletVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OptionletVolatilityStructure > *)jarg1;
  arg1 = (OptionletVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Real)((OptionletVolatilityStructure const *)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_delete_OptionletVolatilityStructure(void * jarg1) {
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  ext::shared_ptr< OptionletVolatilityStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OptionletVolatilityStructure > *)jarg1;
  arg1 = (OptionletVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionletVolatilityStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< OptionletVolatilityStructure > *arg1 = 0 ;
  ext::shared_ptr< OptionletVolatilityStructure > tempnull1 ;
  Handle< OptionletVolatilityStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OptionletVolatilityStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Handle< OptionletVolatilityStructure > *)new Handle< OptionletVolatilityStructure >((ext::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 ;
  ext::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 = result ? new ext::shared_ptr< OptionletVolatilityStructure >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_currentLink(void * jarg1) {
  void * jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  ext::shared_ptr< OptionletVolatilityStructure > result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< OptionletVolatilityStructure >(result) : 0; 
  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 ;
  ext::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 = result ? new ext::shared_ptr< Observable >(result) : 0; 
  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 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 & 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 & 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 & 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 & 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 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 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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructureHandle_timeFromReference(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time result;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)(*arg1)->timeFromReference((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_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(result); 
  return jresult;
}


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(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(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 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 ;
  ext::shared_ptr< OptionletVolatilityStructure > *arg1 = 0 ;
  ext::shared_ptr< OptionletVolatilityStructure > tempnull1 ;
  RelinkableHandle< OptionletVolatilityStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OptionletVolatilityStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (RelinkableHandle< OptionletVolatilityStructure > *)new RelinkableHandle< OptionletVolatilityStructure >((ext::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 ;
  ext::shared_ptr< OptionletVolatilityStructure > *arg2 = 0 ;
  ext::shared_ptr< OptionletVolatilityStructure > tempnull2 ;
  
  arg1 = (RelinkableHandle< OptionletVolatilityStructure > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< OptionletVolatilityStructure > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->linkTo((ext::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_RelinkableOptionletVolatilityStructureHandle_reset(void * jarg1) {
  RelinkableHandle< OptionletVolatilityStructure > *arg1 = (RelinkableHandle< OptionletVolatilityStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< OptionletVolatilityStructure > *)jarg1; 
  {
    try {
      RelinkableHandle_Sl_OptionletVolatilityStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_YoYOptionletVolatilitySurface_observationLag(void * jarg1) {
  void * jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Period result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((YoYOptionletVolatilitySurface const *)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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurface_frequency(void * jarg1) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface 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 = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurface_indexIsInterpolated(void * jarg1) {
  unsigned int jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((YoYOptionletVolatilitySurface const *)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 void * SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurface_baseDate(void * jarg1) {
  void * jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((YoYOptionletVolatilitySurface const *)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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurface_timeFromBase__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Time result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)((YoYOptionletVolatilitySurface const *)arg1)->timeFromBase((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_YoYOptionletVolatilitySurface_timeFromBase__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Time result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)((YoYOptionletVolatilitySurface const *)arg1)->timeFromBase((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_YoYOptionletVolatilitySurface_minStrike(void * jarg1) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)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_YoYOptionletVolatilitySurface_maxStrike(void * jarg1) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)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_YoYOptionletVolatilitySurface_baseLevel(void * jarg1) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Volatility)((YoYOptionletVolatilitySurface const *)arg1)->baseLevel();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurface_volatility__SWIG_0(void * jarg1, void * jarg2, double jarg3, void * jarg4, unsigned int jarg5) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Period *arg4 = 0 ;
  bool arg5 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Volatility)((YoYOptionletVolatilitySurface const *)arg1)->volatility((Date const &)*arg2,arg3,(Period 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_YoYOptionletVolatilitySurface_volatility__SWIG_1(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Period *arg4 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Volatility)((YoYOptionletVolatilitySurface const *)arg1)->volatility((Date const &)*arg2,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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurface_volatility__SWIG_2(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)((YoYOptionletVolatilitySurface const *)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_YoYOptionletVolatilitySurface_volatility__SWIG_3(void * jarg1, void * jarg2, double jarg3, void * jarg4, unsigned int jarg5) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Period *arg2 = 0 ;
  Real arg3 ;
  Period *arg4 = 0 ;
  bool arg5 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Volatility)((YoYOptionletVolatilitySurface const *)arg1)->volatility((Period const &)*arg2,arg3,(Period 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_YoYOptionletVolatilitySurface_volatility__SWIG_4(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Period *arg2 = 0 ;
  Real arg3 ;
  Period *arg4 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Volatility)((YoYOptionletVolatilitySurface const *)arg1)->volatility((Period const &)*arg2,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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurface_volatility__SWIG_5(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Period *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)((YoYOptionletVolatilitySurface const *)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_YoYOptionletVolatilitySurface_totalVariance__SWIG_0(void * jarg1, void * jarg2, double jarg3, void * jarg4, unsigned int jarg5) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  bool arg5 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)arg1)->totalVariance((Date const &)*arg2,arg3,(Period 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_YoYOptionletVolatilitySurface_totalVariance__SWIG_1(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)arg1)->totalVariance((Date const &)*arg2,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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurface_totalVariance__SWIG_2(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)arg1)->totalVariance((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_YoYOptionletVolatilitySurface_totalVariance__SWIG_3(void * jarg1, void * jarg2, double jarg3, void * jarg4, unsigned int jarg5) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  bool arg5 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)arg1)->totalVariance((Period const &)*arg2,arg3,(Period 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_YoYOptionletVolatilitySurface_totalVariance__SWIG_4(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)arg1)->totalVariance((Period const &)*arg2,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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurface_totalVariance__SWIG_5(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)arg1)->totalVariance((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 void SWIGSTDCALL CSharp_QuantLib_delete_YoYOptionletVolatilitySurface(void * jarg1) {
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YoYOptionletVolatilitySurface > *)jarg1;
  arg1 = (YoYOptionletVolatilitySurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYOptionletVolatilitySurfaceHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > *arg1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > tempnull1 ;
  Handle< YoYOptionletVolatilitySurface > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< YoYOptionletVolatilitySurface > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Handle< YoYOptionletVolatilitySurface > *)new Handle< YoYOptionletVolatilitySurface >((ext::shared_ptr< YoYOptionletVolatilitySurface > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle___deref__(void * jarg1) {
  void * jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)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 = result ? new ext::shared_ptr< YoYOptionletVolatilitySurface >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_currentLink(void * jarg1) {
  void * jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< YoYOptionletVolatilitySurface >(result) : 0; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_empty(void * jarg1) {
  unsigned int jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  bool result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)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_YoYOptionletVolatilitySurfaceHandle_asObservable(void * jarg1) {
  void * jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  ext::shared_ptr< Observable > result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  {
    try {
      result = Handle_Sl_YoYOptionletVolatilitySurface_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 = result ? new ext::shared_ptr< Observable >(result) : 0; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_observationLag(void * jarg1) {
  void * jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Period result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_frequency(void * jarg1) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Real result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  {
    try {
      result = (Real)(*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 = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_indexIsInterpolated(void * jarg1) {
  unsigned int jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  bool result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)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 void * SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_baseDate(void * jarg1) {
  void * jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_timeFromBase__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Time result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)(*arg1)->timeFromBase((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_YoYOptionletVolatilitySurfaceHandle_timeFromBase__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  Time result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)(*arg1)->timeFromBase((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_YoYOptionletVolatilitySurfaceHandle_minStrike(void * jarg1) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Real result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)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_YoYOptionletVolatilitySurfaceHandle_maxStrike(void * jarg1) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Real result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)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_YoYOptionletVolatilitySurfaceHandle_baseLevel(void * jarg1) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Volatility result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  {
    try {
      result = (Volatility)(*arg1)->baseLevel();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_0(void * jarg1, void * jarg2, double jarg3, void * jarg4, unsigned int jarg5) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Period *arg4 = 0 ;
  bool arg5 ;
  Volatility result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,arg3,(Period 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_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_1(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Period *arg4 = 0 ;
  Volatility result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_2(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Volatility result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_3(void * jarg1, void * jarg2, double jarg3, void * jarg4, unsigned int jarg5) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Period *arg2 = 0 ;
  Real arg3 ;
  Period *arg4 = 0 ;
  bool arg5 ;
  Volatility result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Period const &)*arg2,arg3,(Period 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_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_4(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Period *arg2 = 0 ;
  Real arg3 ;
  Period *arg4 = 0 ;
  Volatility result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Volatility)(*arg1)->volatility((Period const &)*arg2,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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_5(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Period *arg2 = 0 ;
  Real arg3 ;
  Volatility result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Real)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_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_0(void * jarg1, void * jarg2, double jarg3, void * jarg4, unsigned int jarg5) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  bool arg5 ;
  Real result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->totalVariance((Date const &)*arg2,arg3,(Period 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_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_1(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  Real result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->totalVariance((Date const &)*arg2,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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_2(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  Real result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Real)(*arg1)->totalVariance((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_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_3(void * jarg1, void * jarg2, double jarg3, void * jarg4, unsigned int jarg5) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  bool arg5 ;
  Real result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->totalVariance((Period const &)*arg2,arg3,(Period 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_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_4(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  Real result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->totalVariance((Period const &)*arg2,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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_5(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  Real result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Real)(*arg1)->totalVariance((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 void * SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_dayCounter(void * jarg1) {
  void * jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_timeFromReference(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  Time result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)(*arg1)->timeFromReference((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_YoYOptionletVolatilitySurfaceHandle_calendar(void * jarg1) {
  void * jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_referenceDate(void * jarg1) {
  void * jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_maxDate(void * jarg1) {
  void * jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurfaceHandle_maxTime(void * jarg1) {
  double jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Time result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)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_YoYOptionletVolatilitySurfaceHandle_enableExtrapolation(void * jarg1) {
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)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_YoYOptionletVolatilitySurfaceHandle_disableExtrapolation(void * jarg1) {
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)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_YoYOptionletVolatilitySurfaceHandle_allowsExtrapolation(void * jarg1) {
  unsigned int jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  bool result;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)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_RelinkableYoYOptionletVolatilitySurfaceHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > *arg1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > tempnull1 ;
  RelinkableHandle< YoYOptionletVolatilitySurface > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< YoYOptionletVolatilitySurface > *)jarg1 : &tempnull1; 
  {
    try {
      result = (RelinkableHandle< YoYOptionletVolatilitySurface > *)new RelinkableHandle< YoYOptionletVolatilitySurface >((ext::shared_ptr< YoYOptionletVolatilitySurface > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RelinkableYoYOptionletVolatilitySurfaceHandle_linkTo(void * jarg1, void * jarg2) {
  RelinkableHandle< YoYOptionletVolatilitySurface > *arg1 = (RelinkableHandle< YoYOptionletVolatilitySurface > *) 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > *arg2 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > tempnull2 ;
  
  arg1 = (RelinkableHandle< YoYOptionletVolatilitySurface > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< YoYOptionletVolatilitySurface > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->linkTo((ext::shared_ptr< YoYOptionletVolatilitySurface > 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_RelinkableYoYOptionletVolatilitySurfaceHandle_reset(void * jarg1) {
  RelinkableHandle< YoYOptionletVolatilitySurface > *arg1 = (RelinkableHandle< YoYOptionletVolatilitySurface > *) 0 ;
  
  arg1 = (RelinkableHandle< YoYOptionletVolatilitySurface > *)jarg1; 
  {
    try {
      RelinkableHandle_Sl_YoYOptionletVolatilitySurface_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_RelinkableYoYOptionletVolatilitySurfaceHandle(void * jarg1) {
  RelinkableHandle< YoYOptionletVolatilitySurface > *arg1 = (RelinkableHandle< YoYOptionletVolatilitySurface > *) 0 ;
  
  arg1 = (RelinkableHandle< YoYOptionletVolatilitySurface > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_SmileSection_minStrike(void * jarg1) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((SmileSection const *)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_SmileSection_maxStrike(void * jarg1) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((SmileSection const *)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_SmileSection_atmLevel(void * jarg1) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((SmileSection const *)arg1)->atmLevel();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SmileSection_variance(void * jarg1, double jarg2) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  {
    try {
      result = (Real)((SmileSection const *)arg1)->variance(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SmileSection_volatility__SWIG_0(void * jarg1, double jarg2) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  {
    try {
      result = (Volatility)((SmileSection const *)arg1)->volatility(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SmileSection_exerciseDate(void * jarg1) {
  void * jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Date *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Date *) &((SmileSection const *)arg1)->exerciseDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_SmileSection_volatilityType(void * jarg1) {
  int jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  VolatilityType result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (VolatilityType)((SmileSection 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 double SWIGSTDCALL CSharp_QuantLib_SmileSection_shift(void * jarg1) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((SmileSection const *)arg1)->shift();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SmileSection_referenceDate(void * jarg1) {
  void * jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Date *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Date *) &((SmileSection const *)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 = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SmileSection_exerciseTime(void * jarg1) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Time result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Time)((SmileSection const *)arg1)->exerciseTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SmileSection_dayCounter(void * jarg1) {
  void * jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  ext::shared_ptr< SmileSection > *smartarg1 = 0 ;
  DayCounter *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (DayCounter *) &(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 = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SmileSection_optionPrice__SWIG_0(void * jarg1, double jarg2, int jarg3, double jarg4) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  Option::Type arg3 ;
  Real arg4 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  arg3 = (Option::Type)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)((SmileSection const *)arg1)->optionPrice(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_SmileSection_optionPrice__SWIG_1(void * jarg1, double jarg2, int jarg3) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  Option::Type arg3 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  arg3 = (Option::Type)jarg3; 
  {
    try {
      result = (Real)((SmileSection const *)arg1)->optionPrice(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_SmileSection_optionPrice__SWIG_2(void * jarg1, double jarg2) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  {
    try {
      result = (Real)((SmileSection const *)arg1)->optionPrice(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SmileSection_digitalOptionPrice__SWIG_0(void * jarg1, double jarg2, int jarg3, double jarg4, double jarg5) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  Option::Type arg3 ;
  Real arg4 ;
  Real arg5 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  arg3 = (Option::Type)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)((SmileSection const *)arg1)->digitalOptionPrice(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_SmileSection_digitalOptionPrice__SWIG_1(void * jarg1, double jarg2, int jarg3, double jarg4) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  Option::Type arg3 ;
  Real arg4 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  arg3 = (Option::Type)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)((SmileSection const *)arg1)->digitalOptionPrice(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_SmileSection_digitalOptionPrice__SWIG_2(void * jarg1, double jarg2, int jarg3) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  Option::Type arg3 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  arg3 = (Option::Type)jarg3; 
  {
    try {
      result = (Real)((SmileSection const *)arg1)->digitalOptionPrice(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_SmileSection_digitalOptionPrice__SWIG_3(void * jarg1, double jarg2) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  {
    try {
      result = (Real)((SmileSection const *)arg1)->digitalOptionPrice(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SmileSection_vega__SWIG_0(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  Real arg3 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((SmileSection const *)arg1)->vega(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_SmileSection_vega__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  {
    try {
      result = (Real)((SmileSection 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_SmileSection_density__SWIG_0(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  Real arg3 ;
  Real arg4 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)((SmileSection const *)arg1)->density(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_SmileSection_density__SWIG_1(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  Real arg3 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((SmileSection const *)arg1)->density(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_SmileSection_density__SWIG_2(void * jarg1, double jarg2) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  {
    try {
      result = (Real)((SmileSection const *)arg1)->density(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SmileSection_volatility__SWIG_1(void * jarg1, double jarg2, int jarg3, double jarg4) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  VolatilityType arg3 ;
  Real arg4 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  arg3 = (VolatilityType)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Volatility)((SmileSection const *)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_SmileSection_volatility__SWIG_2(void * jarg1, double jarg2, int jarg3) {
  double jresult ;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  VolatilityType arg3 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  arg3 = (VolatilityType)jarg3; 
  {
    try {
      result = (Volatility)((SmileSection const *)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_delete_SmileSection(void * jarg1) {
  SmileSection *arg1 = (SmileSection *) 0 ;
  ext::shared_ptr< SmileSection > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SmileSection > *)jarg1;
  arg1 = (SmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SmileSectionVector_Clear(void * jarg1) {
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)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_SmileSectionVector_Add(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  ext::shared_ptr< SmileSection > *arg2 = 0 ;
  ext::shared_ptr< SmileSection > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SmileSection > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::shared_ptr< SmileSection > 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_SmileSectionVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< SmileSection > > 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_SmileSectionVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< SmileSection > > 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_SmileSectionVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< SmileSection > >::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_SmileSectionVector__SWIG_0() {
  void * jresult ;
  std::vector< ext::shared_ptr< SmileSection > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< SmileSection > > *)new std::vector< ext::shared_ptr< SmileSection > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SmileSectionVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< ext::shared_ptr< SmileSection > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< SmileSection > > *)new_std_vector_Sl_ext_shared_ptr_Sl_SmileSection_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_SmileSectionVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< SmileSection > result;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_SmileSection_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 = result ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SmileSectionVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< SmileSection > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_SmileSection_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 = *result ? new std::vector< ext::shared_ptr< SmileSection > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SmileSectionVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< SmileSection > *arg3 = 0 ;
  ext::shared_ptr< SmileSection > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< SmileSection > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__setitem(arg1,arg2,(ext::shared_ptr< SmileSection > 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_SmileSectionVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< SmileSection > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__AddRange(arg1,(std::vector< ext::shared_ptr< SmileSection > > 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_SmileSectionVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< SmileSection > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< SmileSection > > *)std_vector_Sl_ext_shared_ptr_Sl_SmileSection_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_SmileSectionVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< SmileSection > *arg3 = 0 ;
  ext::shared_ptr< SmileSection > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< SmileSection > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__Insert(arg1,arg2,(ext::shared_ptr< SmileSection > 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_SmileSectionVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< SmileSection > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< SmileSection > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::shared_ptr< SmileSection > > 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_SmileSectionVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SmileSection_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_SmileSectionVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SmileSection_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_SmileSectionVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< SmileSection > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< SmileSection > tempnull1 ;
  std::vector< ext::shared_ptr< SmileSection > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< SmileSection > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< SmileSection > > *)std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__Repeat((ext::shared_ptr< SmileSection > 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_SmileSectionVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_SmileSection_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_SmileSectionVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SmileSection_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_SmileSectionVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< SmileSection > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< SmileSection > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::shared_ptr< SmileSection > > 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_SmileSectionVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  ext::shared_ptr< SmileSection > *arg2 = 0 ;
  ext::shared_ptr< SmileSection > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SmileSection > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__Contains(arg1,(ext::shared_ptr< SmileSection > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_SmileSectionVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  ext::shared_ptr< SmileSection > *arg2 = 0 ;
  ext::shared_ptr< SmileSection > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SmileSection > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__IndexOf(arg1,(ext::shared_ptr< SmileSection > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_SmileSectionVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  ext::shared_ptr< SmileSection > *arg2 = 0 ;
  ext::shared_ptr< SmileSection > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SmileSection > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__LastIndexOf(arg1,(ext::shared_ptr< SmileSection > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_SmileSectionVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  ext::shared_ptr< SmileSection > *arg2 = 0 ;
  ext::shared_ptr< SmileSection > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SmileSection > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__Remove(arg1,(ext::shared_ptr< SmileSection > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_SmileSectionVector(void * jarg1) {
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< SmileSection > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_SwaptionVolatilityStructure_volatility__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned int jarg5) {
  double jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  bool arg5 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Volatility)((SwaptionVolatilityStructure const *)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 ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Volatility)((SwaptionVolatilityStructure const *)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 ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  bool arg5 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Volatility)((SwaptionVolatilityStructure const *)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 ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Volatility)((SwaptionVolatilityStructure const *)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 ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  bool arg5 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)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 ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)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 ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  bool arg5 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)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 ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)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 ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((SwaptionVolatilityStructure const *)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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_shift__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  double jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift((Period 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_shift__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift((Period 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_SwaptionVolatilityStructure_shift__SWIG_2(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  double jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift((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_shift__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift((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_SwaptionVolatilityStructure_shift__SWIG_4(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4) {
  double jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift(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_shift__SWIG_5(void * jarg1, double jarg2, void * jarg3) {
  double jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift(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_SwaptionVolatilityStructure_shift__SWIG_6(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Time arg3 ;
  bool arg4 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift((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_SwaptionVolatilityStructure_shift__SWIG_7(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift((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_SwaptionVolatilityStructure_shift__SWIG_8(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  bool arg4 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift((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_SwaptionVolatilityStructure_shift__SWIG_9(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift((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_SwaptionVolatilityStructure_shift__SWIG_10(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  bool arg4 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift(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_shift__SWIG_11(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift(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_SwaptionVolatilityStructure_smileSection__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection((Period 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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_smileSection__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection((Period 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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_smileSection__SWIG_2(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection((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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_smileSection__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection((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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_smileSection__SWIG_4(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection(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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_smileSection__SWIG_5(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection(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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_smileSection__SWIG_6(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Time arg3 ;
  bool arg4 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection((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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_smileSection__SWIG_7(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection((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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_smileSection__SWIG_8(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  bool arg4 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection((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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_smileSection__SWIG_9(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection((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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_smileSection__SWIG_10(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  bool arg4 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection(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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_smileSection__SWIG_11(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection(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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SwaptionVolatilityStructure(void * jarg1) {
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SwaptionVolatilityStructure > *)jarg1;
  arg1 = (SwaptionVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< SwaptionVolatilityStructure > *arg1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure > tempnull1 ;
  Handle< SwaptionVolatilityStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< SwaptionVolatilityStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Handle< SwaptionVolatilityStructure > *)new Handle< SwaptionVolatilityStructure >((ext::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 ;
  ext::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 = result ? new ext::shared_ptr< SwaptionVolatilityStructure >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_currentLink(void * jarg1) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< SwaptionVolatilityStructure >(result) : 0; 
  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 ;
  ext::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 = result ? new ext::shared_ptr< Observable >(result) : 0; 
  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 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 & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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 & 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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_shift__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->shift((Period 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_shift__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->shift((Period 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_SwaptionVolatilityStructureHandle_shift__SWIG_2(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->shift((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_shift__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->shift((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_SwaptionVolatilityStructureHandle_shift__SWIG_4(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->shift(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_shift__SWIG_5(void * jarg1, double jarg2, void * jarg3) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Period *arg3 = 0 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->shift(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_SwaptionVolatilityStructureHandle_shift__SWIG_6(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Time arg3 ;
  bool arg4 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->shift((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_SwaptionVolatilityStructureHandle_shift__SWIG_7(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Time arg3 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)(*arg1)->shift((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_SwaptionVolatilityStructureHandle_shift__SWIG_8(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  bool arg4 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->shift((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_SwaptionVolatilityStructureHandle_shift__SWIG_9(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)(*arg1)->shift((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_SwaptionVolatilityStructureHandle_shift__SWIG_10(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  bool arg4 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Real)(*arg1)->shift(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_shift__SWIG_11(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)(*arg1)->shift(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_SwaptionVolatilityStructureHandle_smileSection__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< SmileSection > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (*arg1)->smileSection((Period 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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_smileSection__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (*arg1)->smileSection((Period 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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_smileSection__SWIG_2(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< SmileSection > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (*arg1)->smileSection((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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_smileSection__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (*arg1)->smileSection((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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_smileSection__SWIG_4(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< SmileSection > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (*arg1)->smileSection(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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_smileSection__SWIG_5(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (*arg1)->smileSection(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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_smileSection__SWIG_6(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Time arg3 ;
  bool arg4 ;
  ext::shared_ptr< SmileSection > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (*arg1)->smileSection((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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_smileSection__SWIG_7(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< SmileSection > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (*arg1)->smileSection((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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_smileSection__SWIG_8(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  bool arg4 ;
  ext::shared_ptr< SmileSection > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (*arg1)->smileSection((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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_smileSection__SWIG_9(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< SmileSection > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (*arg1)->smileSection((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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_smileSection__SWIG_10(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  bool arg4 ;
  ext::shared_ptr< SmileSection > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (*arg1)->smileSection(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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_smileSection__SWIG_11(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  ext::shared_ptr< SmileSection > result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (*arg1)->smileSection(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 ? new ext::shared_ptr< SmileSection >(result) : 0; 
  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 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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_timeFromReference(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)(*arg1)->timeFromReference((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_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(result); 
  return jresult;
}


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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_maxDate(void * jarg1) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructureHandle_maxTime(void * jarg1) {
  double jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time result;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)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_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 ;
  ext::shared_ptr< SwaptionVolatilityStructure > *arg1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure > tempnull1 ;
  RelinkableHandle< SwaptionVolatilityStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< SwaptionVolatilityStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (RelinkableHandle< SwaptionVolatilityStructure > *)new RelinkableHandle< SwaptionVolatilityStructure >((ext::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 ;
  ext::shared_ptr< SwaptionVolatilityStructure > *arg2 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure > tempnull2 ;
  
  arg1 = (RelinkableHandle< SwaptionVolatilityStructure > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SwaptionVolatilityStructure > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->linkTo((ext::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_RelinkableSwaptionVolatilityStructureHandle_reset(void * jarg1) {
  RelinkableHandle< SwaptionVolatilityStructure > *arg1 = (RelinkableHandle< SwaptionVolatilityStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< SwaptionVolatilityStructure > *)jarg1; 
  {
    try {
      RelinkableHandle_Sl_SwaptionVolatilityStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  BlackConstantVol *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Volatility)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackConstantVol *)new BlackConstantVol((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 = result ? new ext::shared_ptr<  BlackConstantVol >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  BlackConstantVol *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackConstantVol *)new BlackConstantVol((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 = result ? new ext::shared_ptr<  BlackConstantVol >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  BlackConstantVol *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Volatility)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackConstantVol *)new BlackConstantVol(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 = result ? new ext::shared_ptr<  BlackConstantVol >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  BlackConstantVol *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackConstantVol *)new BlackConstantVol(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 = result ? new ext::shared_ptr<  BlackConstantVol >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackConstantVol(void * jarg1) {
  BlackConstantVol *arg1 = (BlackConstantVol *) 0 ;
  ext::shared_ptr< BlackConstantVol > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackConstantVol > *)jarg1;
  arg1 = (BlackConstantVol *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  BlackVarianceCurve *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (BlackVarianceCurve *)new BlackVarianceCurve((Date const &)*arg1,(std::vector< Date > const &)*arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  BlackVarianceCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  BlackVarianceCurve *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackVarianceCurve *)new BlackVarianceCurve((Date const &)*arg1,(std::vector< Date > const &)*arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  BlackVarianceCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackVarianceCurve(void * jarg1) {
  BlackVarianceCurve *arg1 = (BlackVarianceCurve *) 0 ;
  ext::shared_ptr< BlackVarianceCurve > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackVarianceCurve > *)jarg1;
  arg1 = (BlackVarianceCurve *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, const 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 ;
  BlackVarianceSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg5 = (Matrix *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 = (BlackVarianceSurface *)new_BlackVarianceSurface__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 = result ? new ext::shared_ptr<  BlackVarianceSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  BlackVarianceSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg5 = (Matrix *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BlackVarianceSurface::Extrapolation)jarg7; 
  arg8 = (BlackVarianceSurface::Extrapolation)jarg8; 
  {
    try {
      result = (BlackVarianceSurface *)new_BlackVarianceSurface__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 = result ? new ext::shared_ptr<  BlackVarianceSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  BlackVarianceSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg5 = (Matrix *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BlackVarianceSurface::Extrapolation)jarg7; 
  {
    try {
      result = (BlackVarianceSurface *)new_BlackVarianceSurface__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 = result ? new ext::shared_ptr<  BlackVarianceSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  BlackVarianceSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg5 = (Matrix *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackVarianceSurface *)new_BlackVarianceSurface__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 = result ? new ext::shared_ptr<  BlackVarianceSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BlackVarianceSurface_setInterpolation__SWIG_0(void * jarg1, const char * jarg2) {
  BlackVarianceSurface *arg1 = (BlackVarianceSurface *) 0 ;
  std::string *arg2 = 0 ;
  ext::shared_ptr< BlackVarianceSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackVarianceSurface > *)jarg1;
  arg1 = (BlackVarianceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      BlackVarianceSurface_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) {
  BlackVarianceSurface *arg1 = (BlackVarianceSurface *) 0 ;
  ext::shared_ptr< BlackVarianceSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackVarianceSurface > *)jarg1;
  arg1 = (BlackVarianceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      BlackVarianceSurface_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 void SWIGSTDCALL CSharp_QuantLib_delete_BlackVarianceSurface(void * jarg1) {
  BlackVarianceSurface *arg1 = (BlackVarianceSurface *) 0 ;
  ext::shared_ptr< BlackVarianceSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackVarianceSurface > *)jarg1;
  arg1 = (BlackVarianceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ConstantOptionletVolatility *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility((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 = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantOptionletVolatility *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility((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 = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantOptionletVolatility *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility((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 = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantOptionletVolatility *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility((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 = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantOptionletVolatility *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility((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 = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantOptionletVolatility *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility((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 = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantOptionletVolatility *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility(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 = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantOptionletVolatility *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility(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 = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantOptionletVolatility *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility(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 = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantOptionletVolatility *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility(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 = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantOptionletVolatility *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility(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 = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantOptionletVolatility *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility(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 = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ConstantOptionletVolatility(void * jarg1) {
  ConstantOptionletVolatility *arg1 = (ConstantOptionletVolatility *) 0 ;
  ext::shared_ptr< ConstantOptionletVolatility > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ConstantOptionletVolatility > *)jarg1;
  arg1 = (ConstantOptionletVolatility *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility(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 = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility(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 = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility(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 = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility((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 = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility((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 = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility((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 = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility(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 = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility(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 = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility(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 = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility((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 = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility((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 = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (Volatility)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility((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 = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ConstantSwaptionVolatility(void * jarg1) {
  ConstantSwaptionVolatility *arg1 = (ConstantSwaptionVolatility *) 0 ;
  ext::shared_ptr< ConstantSwaptionVolatility > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ConstantSwaptionVolatility > *)jarg1;
  arg1 = (ConstantSwaptionVolatility *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityDiscrete_optionTenors(void * jarg1) {
  void * jresult ;
  SwaptionVolatilityDiscrete *arg1 = (SwaptionVolatilityDiscrete *) 0 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > *smartarg1 = 0 ;
  std::vector< Period > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityDiscrete > *)jarg1;
  arg1 = (SwaptionVolatilityDiscrete *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Period > *) &((SwaptionVolatilityDiscrete const *)arg1)->optionTenors();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityDiscrete_optionDates(void * jarg1) {
  void * jresult ;
  SwaptionVolatilityDiscrete *arg1 = (SwaptionVolatilityDiscrete *) 0 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityDiscrete > *)jarg1;
  arg1 = (SwaptionVolatilityDiscrete *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((SwaptionVolatilityDiscrete const *)arg1)->optionDates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityDiscrete_optionTimes(void * jarg1) {
  void * jresult ;
  SwaptionVolatilityDiscrete *arg1 = (SwaptionVolatilityDiscrete *) 0 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityDiscrete > *)jarg1;
  arg1 = (SwaptionVolatilityDiscrete *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((SwaptionVolatilityDiscrete const *)arg1)->optionTimes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityDiscrete_swapTenors(void * jarg1) {
  void * jresult ;
  SwaptionVolatilityDiscrete *arg1 = (SwaptionVolatilityDiscrete *) 0 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > *smartarg1 = 0 ;
  std::vector< Period > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityDiscrete > *)jarg1;
  arg1 = (SwaptionVolatilityDiscrete *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Period > *) &((SwaptionVolatilityDiscrete const *)arg1)->swapTenors();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityDiscrete_swapLengths(void * jarg1) {
  void * jresult ;
  SwaptionVolatilityDiscrete *arg1 = (SwaptionVolatilityDiscrete *) 0 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityDiscrete > *)jarg1;
  arg1 = (SwaptionVolatilityDiscrete *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((SwaptionVolatilityDiscrete const *)arg1)->swapLengths();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityDiscrete_optionDateFromTime(void * jarg1, double jarg2) {
  void * jresult ;
  SwaptionVolatilityDiscrete *arg1 = (SwaptionVolatilityDiscrete *) 0 ;
  Time arg2 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityDiscrete > *)jarg1;
  arg1 = (SwaptionVolatilityDiscrete *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = ((SwaptionVolatilityDiscrete const *)arg1)->optionDateFromTime(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SwaptionVolatilityDiscrete(void * jarg1) {
  SwaptionVolatilityDiscrete *arg1 = (SwaptionVolatilityDiscrete *) 0 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SwaptionVolatilityDiscrete > *)jarg1;
  arg1 = (SwaptionVolatilityDiscrete *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, unsigned int jarg8, int jarg9, void * jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Date > *arg4 = 0 ;
  std::vector< Period > *arg5 = 0 ;
  Matrix *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  VolatilityType arg9 ;
  Matrix *arg10 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Date > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Period > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg6 = (Matrix *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = (VolatilityType)jarg9; 
  arg10 = (Matrix *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Date > const &)*arg4,(std::vector< Period > const &)*arg5,(Matrix const &)*arg6,(DayCounter const &)*arg7,arg8,arg9,(Matrix 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 = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_1(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, unsigned int jarg8, int jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Date > *arg4 = 0 ;
  std::vector< Period > *arg5 = 0 ;
  Matrix *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  VolatilityType arg9 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Date > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Period > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg6 = (Matrix *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = (VolatilityType)jarg9; 
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Date > const &)*arg4,(std::vector< Period > const &)*arg5,(Matrix const &)*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 = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_2(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, unsigned int jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Date > *arg4 = 0 ;
  std::vector< Period > *arg5 = 0 ;
  Matrix *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Date > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Period > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg6 = (Matrix *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Date > const &)*arg4,(std::vector< Period > const &)*arg5,(Matrix 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 = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_3(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< Date > *arg4 = 0 ;
  std::vector< Period > *arg5 = 0 ;
  Matrix *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Date > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Period > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg6 = (Matrix *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Date > const &)*arg4,(std::vector< Period > 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 = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg2 = (BusinessDayConvention)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((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< Real > > 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 ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg2 = (BusinessDayConvention)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = (VolatilityType)jarg8; 
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((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 = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg2 = (BusinessDayConvention)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((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 = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg2 = (BusinessDayConvention)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((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 = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg2 = (BusinessDayConvention)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg5 = (Matrix *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = (VolatilityType)jarg8; 
  arg9 = (Matrix *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((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 = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg2 = (BusinessDayConvention)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg5 = (Matrix *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = (VolatilityType)jarg8; 
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((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 = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg2 = (BusinessDayConvention)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg5 = (Matrix *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((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 = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  arg1 = (Calendar *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg2 = (BusinessDayConvention)jarg2; 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg5 = (Matrix *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((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 = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_12(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 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (Matrix *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (VolatilityType)jarg7; 
  arg8 = (Matrix *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionVolatilityMatrix *)new_SwaptionVolatilityMatrix__SWIG_12((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 = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_13(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 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (Matrix *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (VolatilityType)jarg7; 
  {
    try {
      result = (SwaptionVolatilityMatrix *)new_SwaptionVolatilityMatrix__SWIG_12((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 = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_14(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 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (Matrix *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (SwaptionVolatilityMatrix *)new_SwaptionVolatilityMatrix__SWIG_12((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 = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwaptionVolatilityMatrix__SWIG_15(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 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (Matrix *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionVolatilityMatrix *)new_SwaptionVolatilityMatrix__SWIG_12((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 = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityMatrix_locate__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  SwaptionVolatilityMatrix *arg1 = (SwaptionVolatilityMatrix *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< SwaptionVolatilityMatrix const > *smartarg1 = 0 ;
  std::pair< unsigned int,unsigned int > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityMatrix > *)jarg1;
  arg1 = (SwaptionVolatilityMatrix *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = SwaptionVolatilityMatrix_locate__SWIG_0((SwaptionVolatilityMatrix const *)arg1,(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 std::pair< unsigned int,unsigned int >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityMatrix_locate__SWIG_1(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  SwaptionVolatilityMatrix *arg1 = (SwaptionVolatilityMatrix *) 0 ;
  Time arg2 ;
  Time arg3 ;
  ext::shared_ptr< SwaptionVolatilityMatrix const > *smartarg1 = 0 ;
  std::pair< unsigned int,unsigned int > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityMatrix > *)jarg1;
  arg1 = (SwaptionVolatilityMatrix *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = SwaptionVolatilityMatrix_locate__SWIG_1((SwaptionVolatilityMatrix 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 = new std::pair< unsigned int,unsigned int >(result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityMatrix_volatilityType(void * jarg1) {
  int jresult ;
  SwaptionVolatilityMatrix *arg1 = (SwaptionVolatilityMatrix *) 0 ;
  ext::shared_ptr< SwaptionVolatilityMatrix const > *smartarg1 = 0 ;
  VolatilityType result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityMatrix > *)jarg1;
  arg1 = (SwaptionVolatilityMatrix *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (VolatilityType)((SwaptionVolatilityMatrix 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_SwaptionVolatilityMatrix(void * jarg1) {
  SwaptionVolatilityMatrix *arg1 = (SwaptionVolatilityMatrix *) 0 ;
  ext::shared_ptr< SwaptionVolatilityMatrix > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SwaptionVolatilityMatrix > *)jarg1;
  arg1 = (SwaptionVolatilityMatrix *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSmileSection__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, int jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  Date *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Real arg6 ;
  VolatilityType arg7 ;
  SabrSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  arg7 = (VolatilityType)jarg7; 
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real > const &)*arg3,(Date 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 = result ? new ext::shared_ptr<  SabrSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSmileSection__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  Date *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Real arg6 ;
  SabrSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real > const &)*arg3,(Date 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 = result ? new ext::shared_ptr<  SabrSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSmileSection__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  Date *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  SabrSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real > const &)*arg3,(Date 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 = result ? new ext::shared_ptr<  SabrSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSmileSection__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  Date *arg4 = 0 ;
  SabrSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  SabrSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSmileSection__SWIG_4(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  SabrSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  SabrSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSmileSection__SWIG_5(double jarg1, double jarg2, void * jarg3, double jarg4, int jarg5) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  VolatilityType arg5 ;
  SabrSmileSection *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (VolatilityType)jarg5; 
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection(arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  SabrSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSmileSection__SWIG_6(double jarg1, double jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  SabrSmileSection *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection(arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  SabrSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSmileSection__SWIG_7(double jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  SabrSmileSection *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection(arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  SabrSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SabrSmileSection_alpha(void * jarg1) {
  double jresult ;
  SabrSmileSection *arg1 = (SabrSmileSection *) 0 ;
  ext::shared_ptr< SabrSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SabrSmileSection > *)jarg1;
  arg1 = (SabrSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((SabrSmileSection 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_SabrSmileSection_beta(void * jarg1) {
  double jresult ;
  SabrSmileSection *arg1 = (SabrSmileSection *) 0 ;
  ext::shared_ptr< SabrSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SabrSmileSection > *)jarg1;
  arg1 = (SabrSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((SabrSmileSection 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 double SWIGSTDCALL CSharp_QuantLib_SabrSmileSection_nu(void * jarg1) {
  double jresult ;
  SabrSmileSection *arg1 = (SabrSmileSection *) 0 ;
  ext::shared_ptr< SabrSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SabrSmileSection > *)jarg1;
  arg1 = (SabrSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((SabrSmileSection const *)arg1)->nu();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SabrSmileSection_rho(void * jarg1) {
  double jresult ;
  SabrSmileSection *arg1 = (SabrSmileSection *) 0 ;
  ext::shared_ptr< SabrSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SabrSmileSection > *)jarg1;
  arg1 = (SabrSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((SabrSmileSection const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_SabrSmileSection(void * jarg1) {
  SabrSmileSection *arg1 = (SabrSmileSection *) 0 ;
  ext::shared_ptr< SabrSmileSection > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SabrSmileSection > *)jarg1;
  arg1 = (SabrSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SviSmileSection__SWIG_0(double jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > arg3 ;
  std::vector< Real > *argp3 ;
  SviSmileSection *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  argp3 = (std::vector< Real > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (SviSmileSection *)new SviSmileSection(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 ? new ext::shared_ptr<  SviSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SviSmileSection__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > arg3 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real > *argp3 ;
  SviSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  argp3 = (std::vector< Real > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SviSmileSection *)new SviSmileSection((Date const &)*arg1,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 = result ? new ext::shared_ptr<  SviSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SviSmileSection__SWIG_2(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > arg3 ;
  std::vector< Real > *argp3 ;
  SviSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  argp3 = (std::vector< Real > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (SviSmileSection *)new SviSmileSection((Date 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 ? new ext::shared_ptr<  SviSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SviSmileSection(void * jarg1) {
  SviSmileSection *arg1 = (SviSmileSection *) 0 ;
  ext::shared_ptr< SviSmileSection > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SviSmileSection > *)jarg1;
  arg1 = (SviSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SviInterpolatedSmileSection__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19, void * jarg20) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > arg2 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > arg5 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > arg18 ;
  ext::shared_ptr< OptimizationMethod > arg19 ;
  DayCounter *arg20 = 0 ;
  Handle< Quote > *argp2 ;
  Handle< Quote > *argp5 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  argp2 = (Handle< Quote > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  argp5 = (Handle< Quote > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg5 = *argp5; 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  if (jarg18) arg18 = *(ext::shared_ptr< EndCriteria > *)jarg18; 
  if (jarg19) arg19 = *(ext::shared_ptr< OptimizationMethod > *)jarg19; 
  arg20 = (DayCounter *)jarg20;
  if (!arg20) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,arg2,(std::vector< Rate > const &)*arg3,arg4,arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,(DayCounter const &)*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 = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SviInterpolatedSmileSection__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > arg2 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > arg5 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > arg18 ;
  ext::shared_ptr< OptimizationMethod > arg19 ;
  Handle< Quote > *argp2 ;
  Handle< Quote > *argp5 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  argp2 = (Handle< Quote > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  argp5 = (Handle< Quote > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg5 = *argp5; 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  if (jarg18) arg18 = *(ext::shared_ptr< EndCriteria > *)jarg18; 
  if (jarg19) arg19 = *(ext::shared_ptr< OptimizationMethod > *)jarg19; 
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,arg2,(std::vector< Rate > const &)*arg3,arg4,arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,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 = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SviInterpolatedSmileSection__SWIG_2(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > arg2 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > arg5 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > arg18 ;
  Handle< Quote > *argp2 ;
  Handle< Quote > *argp5 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  argp2 = (Handle< Quote > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  argp5 = (Handle< Quote > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg5 = *argp5; 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  if (jarg18) arg18 = *(ext::shared_ptr< EndCriteria > *)jarg18; 
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,arg2,(std::vector< Rate > const &)*arg3,arg4,arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,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 = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SviInterpolatedSmileSection__SWIG_3(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > arg2 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > arg5 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  Handle< Quote > *argp2 ;
  Handle< Quote > *argp5 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  argp2 = (Handle< Quote > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  argp5 = (Handle< Quote > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg5 = *argp5; 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,arg2,(std::vector< Rate > const &)*arg3,arg4,arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,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 = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SviInterpolatedSmileSection__SWIG_4(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > arg2 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > arg5 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  Handle< Quote > *argp2 ;
  Handle< Quote > *argp5 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  argp2 = (Handle< Quote > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  argp5 = (Handle< Quote > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg5 = *argp5; 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,arg2,(std::vector< Rate > const &)*arg3,arg4,arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SviInterpolatedSmileSection__SWIG_5(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19, void * jarg20) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > arg18 ;
  ext::shared_ptr< OptimizationMethod > arg19 ;
  DayCounter *arg20 = 0 ;
  Rate temp2 ;
  Volatility temp5 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  if (jarg18) arg18 = *(ext::shared_ptr< EndCriteria > *)jarg18; 
  if (jarg19) arg19 = *(ext::shared_ptr< OptimizationMethod > *)jarg19; 
  arg20 = (DayCounter *)jarg20;
  if (!arg20) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,(DayCounter const &)*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 = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SviInterpolatedSmileSection__SWIG_6(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > arg18 ;
  ext::shared_ptr< OptimizationMethod > arg19 ;
  Rate temp2 ;
  Volatility temp5 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  if (jarg18) arg18 = *(ext::shared_ptr< EndCriteria > *)jarg18; 
  if (jarg19) arg19 = *(ext::shared_ptr< OptimizationMethod > *)jarg19; 
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,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 = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SviInterpolatedSmileSection__SWIG_7(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > arg18 ;
  Rate temp2 ;
  Volatility temp5 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  if (jarg18) arg18 = *(ext::shared_ptr< EndCriteria > *)jarg18; 
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,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 = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SviInterpolatedSmileSection__SWIG_8(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  Rate temp2 ;
  Volatility temp5 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,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 = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SviInterpolatedSmileSection__SWIG_9(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  Rate temp2 ;
  Volatility temp5 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SviInterpolatedSmileSection_a(void * jarg1) {
  double jresult ;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SviInterpolatedSmileSection > *)jarg1;
  arg1 = (SviInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((SviInterpolatedSmileSection const *)arg1)->a();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SviInterpolatedSmileSection_b(void * jarg1) {
  double jresult ;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SviInterpolatedSmileSection > *)jarg1;
  arg1 = (SviInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((SviInterpolatedSmileSection const *)arg1)->b();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SviInterpolatedSmileSection_sigma(void * jarg1) {
  double jresult ;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SviInterpolatedSmileSection > *)jarg1;
  arg1 = (SviInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((SviInterpolatedSmileSection const *)arg1)->sigma();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SviInterpolatedSmileSection_rho(void * jarg1) {
  double jresult ;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SviInterpolatedSmileSection > *)jarg1;
  arg1 = (SviInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((SviInterpolatedSmileSection const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SviInterpolatedSmileSection_m(void * jarg1) {
  double jresult ;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SviInterpolatedSmileSection > *)jarg1;
  arg1 = (SviInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((SviInterpolatedSmileSection const *)arg1)->m();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SviInterpolatedSmileSection_rmsError(void * jarg1) {
  double jresult ;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SviInterpolatedSmileSection > *)jarg1;
  arg1 = (SviInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((SviInterpolatedSmileSection const *)arg1)->rmsError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SviInterpolatedSmileSection_maxError(void * jarg1) {
  double jresult ;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SviInterpolatedSmileSection > *)jarg1;
  arg1 = (SviInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((SviInterpolatedSmileSection const *)arg1)->maxError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_SviInterpolatedSmileSection_endCriteria(void * jarg1) {
  int jresult ;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > *smartarg1 = 0 ;
  EndCriteria::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const SviInterpolatedSmileSection > *)jarg1;
  arg1 = (SviInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (EndCriteria::Type)((SviInterpolatedSmileSection const *)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_delete_SviInterpolatedSmileSection(void * jarg1) {
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SviInterpolatedSmileSection > *)jarg1;
  arg1 = (SviInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_SwaptionVolatilityCube_atmStrike(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  SwaptionVolatilityCube *arg1 = (SwaptionVolatilityCube *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< SwaptionVolatilityCube const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionVolatilityCube > *)jarg1;
  arg1 = (SwaptionVolatilityCube *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)((SwaptionVolatilityCube const *)arg1)->atmStrike((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_delete_SwaptionVolatilityCube(void * jarg1) {
  SwaptionVolatilityCube *arg1 = (SwaptionVolatilityCube *) 0 ;
  ext::shared_ptr< SwaptionVolatilityCube > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SwaptionVolatilityCube > *)jarg1;
  arg1 = (SwaptionVolatilityCube *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSwaptionVolatilityCube__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, double jarg15, unsigned int jarg16, unsigned long jarg17, unsigned int jarg18, double jarg19) {
  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 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote > > > *arg9 = 0 ;
  std::vector< bool > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< EndCriteria > *arg12 = 0 ;
  Real arg13 ;
  ext::shared_ptr< OptimizationMethod > *arg14 = 0 ;
  Real arg15 ;
  bool arg16 ;
  Size arg17 ;
  bool arg18 ;
  Real arg19 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  ext::shared_ptr< SwapIndex > tempnull7 ;
  ext::shared_ptr< EndCriteria > tempnull12 ;
  ext::shared_ptr< OptimizationMethod > tempnull14 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Period > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Spread > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = jarg7 ? (ext::shared_ptr< SwapIndex > *)jarg7 : &tempnull7; 
  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 & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< bool > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? (ext::shared_ptr< EndCriteria > *)jarg12 : &tempnull12; 
  arg13 = (Real)jarg13; 
  arg14 = jarg14 ? (ext::shared_ptr< OptimizationMethod > *)jarg14 : &tempnull14; 
  arg15 = (Real)jarg15; 
  arg16 = jarg16 ? true : false; 
  arg17 = (Size)jarg17; 
  arg18 = jarg18 ? true : false; 
  arg19 = (Real)jarg19; 
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period > const &)*arg2,(std::vector< Period > const &)*arg3,(std::vector< Spread > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote > > > const &)*arg9,(std::vector< bool > const &)*arg10,arg11,(ext::shared_ptr< EndCriteria > const &)*arg12,arg13,(ext::shared_ptr< OptimizationMethod > const &)*arg14,arg15,arg16,arg17,arg18,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 = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSwaptionVolatilityCube__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 * jarg14, double jarg15, unsigned int jarg16, unsigned long jarg17, unsigned int jarg18) {
  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 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote > > > *arg9 = 0 ;
  std::vector< bool > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< EndCriteria > *arg12 = 0 ;
  Real arg13 ;
  ext::shared_ptr< OptimizationMethod > *arg14 = 0 ;
  Real arg15 ;
  bool arg16 ;
  Size arg17 ;
  bool arg18 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  ext::shared_ptr< SwapIndex > tempnull7 ;
  ext::shared_ptr< EndCriteria > tempnull12 ;
  ext::shared_ptr< OptimizationMethod > tempnull14 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Period > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Spread > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = jarg7 ? (ext::shared_ptr< SwapIndex > *)jarg7 : &tempnull7; 
  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 & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< bool > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? (ext::shared_ptr< EndCriteria > *)jarg12 : &tempnull12; 
  arg13 = (Real)jarg13; 
  arg14 = jarg14 ? (ext::shared_ptr< OptimizationMethod > *)jarg14 : &tempnull14; 
  arg15 = (Real)jarg15; 
  arg16 = jarg16 ? true : false; 
  arg17 = (Size)jarg17; 
  arg18 = jarg18 ? true : false; 
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period > const &)*arg2,(std::vector< Period > const &)*arg3,(std::vector< Spread > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote > > > const &)*arg9,(std::vector< bool > const &)*arg10,arg11,(ext::shared_ptr< EndCriteria > const &)*arg12,arg13,(ext::shared_ptr< OptimizationMethod > const &)*arg14,arg15,arg16,arg17,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 = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSwaptionVolatilityCube__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, double jarg13, void * jarg14, double jarg15, unsigned int jarg16, unsigned long jarg17) {
  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 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote > > > *arg9 = 0 ;
  std::vector< bool > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< EndCriteria > *arg12 = 0 ;
  Real arg13 ;
  ext::shared_ptr< OptimizationMethod > *arg14 = 0 ;
  Real arg15 ;
  bool arg16 ;
  Size arg17 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  ext::shared_ptr< SwapIndex > tempnull7 ;
  ext::shared_ptr< EndCriteria > tempnull12 ;
  ext::shared_ptr< OptimizationMethod > tempnull14 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Period > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Spread > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = jarg7 ? (ext::shared_ptr< SwapIndex > *)jarg7 : &tempnull7; 
  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 & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< bool > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? (ext::shared_ptr< EndCriteria > *)jarg12 : &tempnull12; 
  arg13 = (Real)jarg13; 
  arg14 = jarg14 ? (ext::shared_ptr< OptimizationMethod > *)jarg14 : &tempnull14; 
  arg15 = (Real)jarg15; 
  arg16 = jarg16 ? true : false; 
  arg17 = (Size)jarg17; 
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period > const &)*arg2,(std::vector< Period > const &)*arg3,(std::vector< Spread > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote > > > const &)*arg9,(std::vector< bool > const &)*arg10,arg11,(ext::shared_ptr< EndCriteria > const &)*arg12,arg13,(ext::shared_ptr< OptimizationMethod > const &)*arg14,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 = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSwaptionVolatilityCube__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 * jarg12, double jarg13, void * jarg14, double jarg15, unsigned int jarg16) {
  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 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote > > > *arg9 = 0 ;
  std::vector< bool > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< EndCriteria > *arg12 = 0 ;
  Real arg13 ;
  ext::shared_ptr< OptimizationMethod > *arg14 = 0 ;
  Real arg15 ;
  bool arg16 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  ext::shared_ptr< SwapIndex > tempnull7 ;
  ext::shared_ptr< EndCriteria > tempnull12 ;
  ext::shared_ptr< OptimizationMethod > tempnull14 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Period > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Spread > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = jarg7 ? (ext::shared_ptr< SwapIndex > *)jarg7 : &tempnull7; 
  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 & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< bool > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? (ext::shared_ptr< EndCriteria > *)jarg12 : &tempnull12; 
  arg13 = (Real)jarg13; 
  arg14 = jarg14 ? (ext::shared_ptr< OptimizationMethod > *)jarg14 : &tempnull14; 
  arg15 = (Real)jarg15; 
  arg16 = jarg16 ? true : false; 
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period > const &)*arg2,(std::vector< Period > const &)*arg3,(std::vector< Spread > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote > > > const &)*arg9,(std::vector< bool > const &)*arg10,arg11,(ext::shared_ptr< EndCriteria > const &)*arg12,arg13,(ext::shared_ptr< OptimizationMethod > const &)*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 = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSwaptionVolatilityCube__SWIG_4(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, double jarg15) {
  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 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote > > > *arg9 = 0 ;
  std::vector< bool > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< EndCriteria > *arg12 = 0 ;
  Real arg13 ;
  ext::shared_ptr< OptimizationMethod > *arg14 = 0 ;
  Real arg15 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  ext::shared_ptr< SwapIndex > tempnull7 ;
  ext::shared_ptr< EndCriteria > tempnull12 ;
  ext::shared_ptr< OptimizationMethod > tempnull14 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Period > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Spread > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = jarg7 ? (ext::shared_ptr< SwapIndex > *)jarg7 : &tempnull7; 
  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 & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< bool > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? (ext::shared_ptr< EndCriteria > *)jarg12 : &tempnull12; 
  arg13 = (Real)jarg13; 
  arg14 = jarg14 ? (ext::shared_ptr< OptimizationMethod > *)jarg14 : &tempnull14; 
  arg15 = (Real)jarg15; 
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period > const &)*arg2,(std::vector< Period > const &)*arg3,(std::vector< Spread > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote > > > const &)*arg9,(std::vector< bool > const &)*arg10,arg11,(ext::shared_ptr< EndCriteria > const &)*arg12,arg13,(ext::shared_ptr< OptimizationMethod > const &)*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 = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSwaptionVolatilityCube__SWIG_5(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 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote > > > *arg9 = 0 ;
  std::vector< bool > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< EndCriteria > *arg12 = 0 ;
  Real arg13 ;
  ext::shared_ptr< OptimizationMethod > *arg14 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  ext::shared_ptr< SwapIndex > tempnull7 ;
  ext::shared_ptr< EndCriteria > tempnull12 ;
  ext::shared_ptr< OptimizationMethod > tempnull14 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Period > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Spread > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = jarg7 ? (ext::shared_ptr< SwapIndex > *)jarg7 : &tempnull7; 
  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 & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< bool > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? (ext::shared_ptr< EndCriteria > *)jarg12 : &tempnull12; 
  arg13 = (Real)jarg13; 
  arg14 = jarg14 ? (ext::shared_ptr< OptimizationMethod > *)jarg14 : &tempnull14; 
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period > const &)*arg2,(std::vector< Period > const &)*arg3,(std::vector< Spread > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote > > > const &)*arg9,(std::vector< bool > const &)*arg10,arg11,(ext::shared_ptr< EndCriteria > const &)*arg12,arg13,(ext::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 = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSwaptionVolatilityCube__SWIG_6(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 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote > > > *arg9 = 0 ;
  std::vector< bool > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< EndCriteria > *arg12 = 0 ;
  Real arg13 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  ext::shared_ptr< SwapIndex > tempnull7 ;
  ext::shared_ptr< EndCriteria > tempnull12 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Period > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Spread > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = jarg7 ? (ext::shared_ptr< SwapIndex > *)jarg7 : &tempnull7; 
  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 & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< bool > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? (ext::shared_ptr< EndCriteria > *)jarg12 : &tempnull12; 
  arg13 = (Real)jarg13; 
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period > const &)*arg2,(std::vector< Period > const &)*arg3,(std::vector< Spread > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote > > > const &)*arg9,(std::vector< bool > const &)*arg10,arg11,(ext::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 = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSwaptionVolatilityCube__SWIG_7(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 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote > > > *arg9 = 0 ;
  std::vector< bool > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< EndCriteria > *arg12 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  ext::shared_ptr< SwapIndex > tempnull7 ;
  ext::shared_ptr< EndCriteria > tempnull12 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Period > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Spread > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = jarg7 ? (ext::shared_ptr< SwapIndex > *)jarg7 : &tempnull7; 
  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 & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< bool > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? (ext::shared_ptr< EndCriteria > *)jarg12 : &tempnull12; 
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period > const &)*arg2,(std::vector< Period > const &)*arg3,(std::vector< Spread > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote > > > const &)*arg9,(std::vector< bool > const &)*arg10,arg11,(ext::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 = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SabrSwaptionVolatilityCube__SWIG_8(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 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote > > > *arg9 = 0 ;
  std::vector< bool > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  ext::shared_ptr< SwapIndex > tempnull7 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Period > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Spread > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = jarg7 ? (ext::shared_ptr< SwapIndex > *)jarg7 : &tempnull7; 
  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 & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< bool > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period > const &)*arg2,(std::vector< Period > const &)*arg3,(std::vector< Spread > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SabrSwaptionVolatilityCube_sparseSabrParameters(void * jarg1) {
  void * jresult ;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > *smartarg1 = 0 ;
  Matrix result;
  
  
  smartarg1 = (ext::shared_ptr< const SabrSwaptionVolatilityCube > *)jarg1;
  arg1 = (SabrSwaptionVolatilityCube *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((SabrSwaptionVolatilityCube const *)arg1)->sparseSabrParameters();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SabrSwaptionVolatilityCube_denseSabrParameters(void * jarg1) {
  void * jresult ;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > *smartarg1 = 0 ;
  Matrix result;
  
  
  smartarg1 = (ext::shared_ptr< const SabrSwaptionVolatilityCube > *)jarg1;
  arg1 = (SabrSwaptionVolatilityCube *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((SabrSwaptionVolatilityCube const *)arg1)->denseSabrParameters();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SabrSwaptionVolatilityCube_marketVolCube(void * jarg1) {
  void * jresult ;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > *smartarg1 = 0 ;
  Matrix result;
  
  
  smartarg1 = (ext::shared_ptr< const SabrSwaptionVolatilityCube > *)jarg1;
  arg1 = (SabrSwaptionVolatilityCube *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((SabrSwaptionVolatilityCube const *)arg1)->marketVolCube();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SabrSwaptionVolatilityCube_volCubeAtmCalibrated(void * jarg1) {
  void * jresult ;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > *smartarg1 = 0 ;
  Matrix result;
  
  
  smartarg1 = (ext::shared_ptr< const SabrSwaptionVolatilityCube > *)jarg1;
  arg1 = (SabrSwaptionVolatilityCube *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((SabrSwaptionVolatilityCube const *)arg1)->volCubeAtmCalibrated();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SabrSwaptionVolatilityCube_smileSection__SWIG_0(void * jarg1, double jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  Time arg2 ;
  Time arg3 ;
  bool arg4 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > *smartarg1 = 0 ;
  ext::shared_ptr< SabrSmileSection > result;
  
  
  smartarg1 = (ext::shared_ptr< const SabrSwaptionVolatilityCube > *)jarg1;
  arg1 = (SabrSwaptionVolatilityCube *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = SabrSwaptionVolatilityCube_smileSection__SWIG_0((SabrSwaptionVolatilityCube 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 ? new ext::shared_ptr< SabrSmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SabrSwaptionVolatilityCube_smileSection__SWIG_1(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  Time arg2 ;
  Time arg3 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > *smartarg1 = 0 ;
  ext::shared_ptr< SabrSmileSection > result;
  
  
  smartarg1 = (ext::shared_ptr< const SabrSwaptionVolatilityCube > *)jarg1;
  arg1 = (SabrSwaptionVolatilityCube *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = SabrSwaptionVolatilityCube_smileSection__SWIG_0((SabrSwaptionVolatilityCube 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 ? new ext::shared_ptr< SabrSmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SabrSwaptionVolatilityCube_smileSection__SWIG_2(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > *smartarg1 = 0 ;
  ext::shared_ptr< SabrSmileSection > result;
  
  
  smartarg1 = (ext::shared_ptr< const SabrSwaptionVolatilityCube > *)jarg1;
  arg1 = (SabrSwaptionVolatilityCube *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = SabrSwaptionVolatilityCube_smileSection__SWIG_2((SabrSwaptionVolatilityCube const *)arg1,(Period 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 ? new ext::shared_ptr< SabrSmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SabrSwaptionVolatilityCube_smileSection__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > *smartarg1 = 0 ;
  ext::shared_ptr< SabrSmileSection > result;
  
  
  smartarg1 = (ext::shared_ptr< const SabrSwaptionVolatilityCube > *)jarg1;
  arg1 = (SabrSwaptionVolatilityCube *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = SabrSwaptionVolatilityCube_smileSection__SWIG_2((SabrSwaptionVolatilityCube const *)arg1,(Period 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 ? new ext::shared_ptr< SabrSmileSection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SabrSwaptionVolatilityCube(void * jarg1) {
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SabrSwaptionVolatilityCube > *)jarg1;
  arg1 = (SabrSwaptionVolatilityCube *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InterpolatedSwaptionVolatilityCube(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 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  ext::shared_ptr< SwapIndex > tempnull7 ;
  InterpolatedSwaptionVolatilityCube *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Period > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Period > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Spread > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = jarg7 ? (ext::shared_ptr< SwapIndex > *)jarg7 : &tempnull7; 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (InterpolatedSwaptionVolatilityCube *)new InterpolatedSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period > const &)*arg2,(std::vector< Period > const &)*arg3,(std::vector< Spread > const &)*arg4,(std::vector< std::vector< Handle< Quote > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > 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 ? new ext::shared_ptr<  InterpolatedSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InterpolatedSwaptionVolatilityCube(void * jarg1) {
  InterpolatedSwaptionVolatilityCube *arg1 = (InterpolatedSwaptionVolatilityCube *) 0 ;
  ext::shared_ptr< InterpolatedSwaptionVolatilityCube > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedSwaptionVolatilityCube > *)jarg1;
  arg1 = (InterpolatedSwaptionVolatilityCube *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantYoYOptionletVolatility__SWIG_0(double jarg1, unsigned int jarg2, void * jarg3, int jarg4, void * jarg5, void * jarg6, int jarg7, unsigned int jarg8, double jarg9, double jarg10) {
  void * jresult ;
  Volatility arg1 ;
  Natural arg2 ;
  Calendar *arg3 = 0 ;
  BusinessDayConvention arg4 ;
  DayCounter *arg5 = 0 ;
  Period *arg6 = 0 ;
  Frequency arg7 ;
  bool arg8 ;
  Real arg9 ;
  Real arg10 ;
  ConstantYoYOptionletVolatility *result = 0 ;
  
  arg1 = (Volatility)jarg1; 
  arg2 = (Natural)jarg2; 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (BusinessDayConvention)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Period *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg7 = (Frequency)jarg7; 
  arg8 = jarg8 ? true : false; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (ConstantYoYOptionletVolatility *)new ConstantYoYOptionletVolatility(arg1,arg2,(Calendar const &)*arg3,arg4,(DayCounter const &)*arg5,(Period 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 = result ? new ext::shared_ptr<  ConstantYoYOptionletVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantYoYOptionletVolatility__SWIG_1(double jarg1, unsigned int jarg2, void * jarg3, int jarg4, void * jarg5, void * jarg6, int jarg7, unsigned int jarg8, double jarg9) {
  void * jresult ;
  Volatility arg1 ;
  Natural arg2 ;
  Calendar *arg3 = 0 ;
  BusinessDayConvention arg4 ;
  DayCounter *arg5 = 0 ;
  Period *arg6 = 0 ;
  Frequency arg7 ;
  bool arg8 ;
  Real arg9 ;
  ConstantYoYOptionletVolatility *result = 0 ;
  
  arg1 = (Volatility)jarg1; 
  arg2 = (Natural)jarg2; 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (BusinessDayConvention)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Period *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg7 = (Frequency)jarg7; 
  arg8 = jarg8 ? true : false; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (ConstantYoYOptionletVolatility *)new ConstantYoYOptionletVolatility(arg1,arg2,(Calendar const &)*arg3,arg4,(DayCounter const &)*arg5,(Period 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 = result ? new ext::shared_ptr<  ConstantYoYOptionletVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstantYoYOptionletVolatility__SWIG_2(double jarg1, unsigned int jarg2, void * jarg3, int jarg4, void * jarg5, void * jarg6, int jarg7, unsigned int jarg8) {
  void * jresult ;
  Volatility arg1 ;
  Natural arg2 ;
  Calendar *arg3 = 0 ;
  BusinessDayConvention arg4 ;
  DayCounter *arg5 = 0 ;
  Period *arg6 = 0 ;
  Frequency arg7 ;
  bool arg8 ;
  ConstantYoYOptionletVolatility *result = 0 ;
  
  arg1 = (Volatility)jarg1; 
  arg2 = (Natural)jarg2; 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (BusinessDayConvention)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Period *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg7 = (Frequency)jarg7; 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (ConstantYoYOptionletVolatility *)new ConstantYoYOptionletVolatility(arg1,arg2,(Calendar const &)*arg3,arg4,(DayCounter const &)*arg5,(Period 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 ? new ext::shared_ptr<  ConstantYoYOptionletVolatility >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ConstantYoYOptionletVolatility(void * jarg1) {
  ConstantYoYOptionletVolatility *arg1 = (ConstantYoYOptionletVolatility *) 0 ;
  ext::shared_ptr< ConstantYoYOptionletVolatility > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ConstantYoYOptionletVolatility > *)jarg1;
  arg1 = (ConstantYoYOptionletVolatility *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatSmileSection__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, int jarg6, double jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  VolatilityType arg6 ;
  Real arg7 ;
  FlatSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Volatility)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (VolatilityType)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection((Date const &)*arg1,arg2,(DayCounter 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 = result ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatSmileSection__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, int jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  VolatilityType arg6 ;
  FlatSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Volatility)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection((Date const &)*arg1,arg2,(DayCounter 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 ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatSmileSection__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  FlatSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Volatility)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection((Date const &)*arg1,arg2,(DayCounter 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 ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatSmileSection__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  Date *arg4 = 0 ;
  FlatSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Volatility)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection((Date const &)*arg1,arg2,(DayCounter 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 ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatSmileSection__SWIG_4(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  FlatSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Volatility)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection((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 = result ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatSmileSection__SWIG_5(double jarg1, double jarg2, void * jarg3, double jarg4, int jarg5, double jarg6) {
  void * jresult ;
  Time arg1 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  Real arg4 ;
  VolatilityType arg5 ;
  Real arg6 ;
  FlatSmileSection *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Volatility)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (VolatilityType)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection(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 ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatSmileSection__SWIG_6(double jarg1, double jarg2, void * jarg3, double jarg4, int jarg5) {
  void * jresult ;
  Time arg1 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  Real arg4 ;
  VolatilityType arg5 ;
  FlatSmileSection *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Volatility)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (VolatilityType)jarg5; 
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection(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 ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatSmileSection__SWIG_7(double jarg1, double jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Time arg1 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  Real arg4 ;
  FlatSmileSection *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Volatility)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection(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 = result ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FlatSmileSection__SWIG_8(double jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Time arg1 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  FlatSmileSection *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Volatility)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection(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 = result ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FlatSmileSection(void * jarg1) {
  FlatSmileSection *arg1 = (FlatSmileSection *) 0 ;
  ext::shared_ptr< FlatSmileSection > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FlatSmileSection > *)jarg1;
  arg1 = (FlatSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_0(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, double jarg8) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Linear *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(Linear 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_1(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Linear *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(Linear 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_2(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Linear *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(Linear 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_3(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Linear *arg5 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_4(double jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_5(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, double jarg8) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  Linear *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(Linear 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_6(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  Linear *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(Linear 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_7(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  Linear *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(Linear 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_8(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  Linear *arg5 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_9(double jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, double jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Linear *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  Real arg9 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Linear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (VolatilityType)jarg8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(Linear const &)*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 ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Linear *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Linear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (VolatilityType)jarg8; 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(Linear const &)*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 ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_12(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Linear *arg6 = 0 ;
  Date *arg7 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Linear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(Linear 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_13(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Linear *arg6 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Linear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(Linear 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 ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_14(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_15(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_16(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, double jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  Linear *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  Real arg9 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Linear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (VolatilityType)jarg8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(DayCounter const &)*arg5,(Linear const &)*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 ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_17(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  Linear *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Linear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (VolatilityType)jarg8; 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(DayCounter const &)*arg5,(Linear const &)*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 ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_18(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  Linear *arg6 = 0 ;
  Date *arg7 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Linear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(DayCounter const &)*arg5,(Linear 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_19(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  Linear *arg6 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Linear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(DayCounter const &)*arg5,(Linear 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 ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_20(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LinearInterpolatedSmileSection__SWIG_21(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LinearInterpolatedSmileSection(void * jarg1) {
  InterpolatedSmileSection< Linear > *arg1 = (InterpolatedSmileSection< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedSmileSection< Linear > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedSmileSection<Linear> > *)jarg1;
  arg1 = (InterpolatedSmileSection<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_0(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, double jarg8) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Cubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (Cubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(Cubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_1(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Cubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (Cubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(Cubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_2(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Cubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (Cubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(Cubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_3(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Cubic *arg5 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (Cubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_4(double jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_5(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, double jarg8) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  Cubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Cubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(Cubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_6(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  Cubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Cubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(Cubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_7(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  Cubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Cubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(Cubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_8(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  Cubic *arg5 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Cubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_9(double jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, double jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  Real arg9 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Cubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (VolatilityType)jarg8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(Cubic const &)*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 ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Cubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (VolatilityType)jarg8; 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(Cubic const &)*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 ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_12(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Cubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(Cubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_13(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Cubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(Cubic 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 ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_14(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_15(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_16(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, double jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  Real arg9 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Cubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (VolatilityType)jarg8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(DayCounter const &)*arg5,(Cubic const &)*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 ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_17(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Cubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (VolatilityType)jarg8; 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(DayCounter const &)*arg5,(Cubic const &)*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 ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_18(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Cubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(DayCounter const &)*arg5,(Cubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_19(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Cubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(DayCounter const &)*arg5,(Cubic 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 ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_20(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CubicInterpolatedSmileSection__SWIG_21(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CubicInterpolatedSmileSection(void * jarg1) {
  InterpolatedSmileSection< Cubic > *arg1 = (InterpolatedSmileSection< Cubic > *) 0 ;
  ext::shared_ptr< InterpolatedSmileSection< Cubic > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *)jarg1;
  arg1 = (InterpolatedSmileSection<Cubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_0(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, double jarg8) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  MonotonicCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (MonotonicCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(MonotonicCubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_1(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  MonotonicCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (MonotonicCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(MonotonicCubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_2(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  MonotonicCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (MonotonicCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(MonotonicCubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_3(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  MonotonicCubic *arg5 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (MonotonicCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_4(double jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_5(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, double jarg8) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  MonotonicCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (MonotonicCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(MonotonicCubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_6(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  MonotonicCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (MonotonicCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(MonotonicCubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_7(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  MonotonicCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (MonotonicCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(MonotonicCubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_8(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  MonotonicCubic *arg5 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (MonotonicCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_9(double jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, double jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  MonotonicCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  Real arg9 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (MonotonicCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (VolatilityType)jarg8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(MonotonicCubic const &)*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 ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  MonotonicCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (MonotonicCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (VolatilityType)jarg8; 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(MonotonicCubic const &)*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 ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_12(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  MonotonicCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (MonotonicCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(MonotonicCubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_13(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  MonotonicCubic *arg6 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (MonotonicCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(MonotonicCubic 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 ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_14(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_15(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_16(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, double jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  MonotonicCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  Real arg9 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (MonotonicCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (VolatilityType)jarg8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(DayCounter const &)*arg5,(MonotonicCubic const &)*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 ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_17(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  MonotonicCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (MonotonicCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (VolatilityType)jarg8; 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(DayCounter const &)*arg5,(MonotonicCubic const &)*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 ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_18(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  MonotonicCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (MonotonicCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(DayCounter const &)*arg5,(MonotonicCubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_19(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  MonotonicCubic *arg6 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (MonotonicCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(DayCounter const &)*arg5,(MonotonicCubic 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 ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_20(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicCubicInterpolatedSmileSection__SWIG_21(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MonotonicCubicInterpolatedSmileSection(void * jarg1) {
  InterpolatedSmileSection< MonotonicCubic > *arg1 = (InterpolatedSmileSection< MonotonicCubic > *) 0 ;
  ext::shared_ptr< InterpolatedSmileSection< MonotonicCubic > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *)jarg1;
  arg1 = (InterpolatedSmileSection<MonotonicCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_0(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, double jarg8) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  SplineCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (SplineCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(SplineCubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_1(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  SplineCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (SplineCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(SplineCubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_2(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  SplineCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (SplineCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(SplineCubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_3(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  SplineCubic *arg5 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (SplineCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(SplineCubic 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 ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_4(double jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_5(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, double jarg8) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  SplineCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (SplineCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(SplineCubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_6(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  SplineCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (SplineCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(SplineCubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_7(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  SplineCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (SplineCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(SplineCubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_8(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  SplineCubic *arg5 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (SplineCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(SplineCubic 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 ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_9(double jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Time arg1 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, double jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  Real arg9 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (SplineCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (VolatilityType)jarg8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(SplineCubic const &)*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 ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (SplineCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (VolatilityType)jarg8; 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(SplineCubic const &)*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 ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_12(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (SplineCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(SplineCubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_13(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (SplineCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(SplineCubic 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 ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_14(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > const &)*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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_15(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Handle< Quote > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Handle< Quote > > 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_16(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, double jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  Real arg9 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (SplineCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (VolatilityType)jarg8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(DayCounter const &)*arg5,(SplineCubic const &)*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 ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_17(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (SplineCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (VolatilityType)jarg8; 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(DayCounter const &)*arg5,(SplineCubic const &)*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 ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_18(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (SplineCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(DayCounter const &)*arg5,(SplineCubic 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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_19(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (SplineCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*arg3,arg4,(DayCounter const &)*arg5,(SplineCubic 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 ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_20(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > const &)*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 = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SplineCubicInterpolatedSmileSection__SWIG_21(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SplineCubicInterpolatedSmileSection(void * jarg1) {
  InterpolatedSmileSection< SplineCubic > *arg1 = (InterpolatedSmileSection< SplineCubic > *) 0 ;
  ext::shared_ptr< InterpolatedSmileSection< SplineCubic > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *)jarg1;
  arg1 = (InterpolatedSmileSection<SplineCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KahaleSmileSection__SWIG_0(void * jarg1, double jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, void * jarg6, double jarg7, int jarg8, int jarg9) {
  void * jresult ;
  ext::shared_ptr< SmileSection > arg1 ;
  Real arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  std::vector< Real > *arg6 = 0 ;
  Real arg7 ;
  int arg8 ;
  int arg9 ;
  KahaleSmileSection *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< SmileSection > *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (int)jarg8; 
  arg9 = (int)jarg9; 
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(arg1,arg2,arg3,arg4,arg5,(std::vector< Real > 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 = result ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KahaleSmileSection__SWIG_1(void * jarg1, double jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, void * jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< SmileSection > arg1 ;
  Real arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  std::vector< Real > *arg6 = 0 ;
  Real arg7 ;
  int arg8 ;
  KahaleSmileSection *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< SmileSection > *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (int)jarg8; 
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(arg1,arg2,arg3,arg4,arg5,(std::vector< Real > 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 ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KahaleSmileSection__SWIG_2(void * jarg1, double jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, void * jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< SmileSection > arg1 ;
  Real arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  std::vector< Real > *arg6 = 0 ;
  Real arg7 ;
  KahaleSmileSection *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< SmileSection > *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(arg1,arg2,arg3,arg4,arg5,(std::vector< Real > 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 ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KahaleSmileSection__SWIG_3(void * jarg1, double jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, void * jarg6) {
  void * jresult ;
  ext::shared_ptr< SmileSection > arg1 ;
  Real arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  std::vector< Real > *arg6 = 0 ;
  KahaleSmileSection *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< SmileSection > *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(arg1,arg2,arg3,arg4,arg5,(std::vector< Real > 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 ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KahaleSmileSection__SWIG_4(void * jarg1, double jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< SmileSection > arg1 ;
  Real arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  KahaleSmileSection *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< SmileSection > *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(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 ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KahaleSmileSection__SWIG_5(void * jarg1, double jarg2, unsigned int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< SmileSection > arg1 ;
  Real arg2 ;
  bool arg3 ;
  bool arg4 ;
  KahaleSmileSection *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< SmileSection > *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(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 ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KahaleSmileSection__SWIG_6(void * jarg1, double jarg2, unsigned int jarg3) {
  void * jresult ;
  ext::shared_ptr< SmileSection > arg1 ;
  Real arg2 ;
  bool arg3 ;
  KahaleSmileSection *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< SmileSection > *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(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 ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KahaleSmileSection__SWIG_7(void * jarg1, double jarg2) {
  void * jresult ;
  ext::shared_ptr< SmileSection > arg1 ;
  Real arg2 ;
  KahaleSmileSection *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< SmileSection > *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(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 ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KahaleSmileSection__SWIG_8(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< SmileSection > arg1 ;
  KahaleSmileSection *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< SmileSection > *)jarg1; 
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_KahaleSmileSection(void * jarg1) {
  KahaleSmileSection *arg1 = (KahaleSmileSection *) 0 ;
  ext::shared_ptr< KahaleSmileSection > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  KahaleSmileSection > *)jarg1;
  arg1 = (KahaleSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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


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


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


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


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


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


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


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalSmileSection__SWIG_0(double jarg1, double jarg2, void * jarg3, void * jarg4, unsigned long jarg5) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Size arg5 ;
  ZabrSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityLognormal > *)new ZabrSmileSection< ZabrShortMaturityLognormal >(arg1,arg2,(std::vector< Real > const &)*arg3,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalSmileSection__SWIG_1(double jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  ZabrSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityLognormal > *)new ZabrSmileSection< ZabrShortMaturityLognormal >(arg1,arg2,(std::vector< Real > const &)*arg3,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalSmileSection__SWIG_2(double jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  ZabrSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityLognormal > *)new ZabrSmileSection< ZabrShortMaturityLognormal >(arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalSmileSection__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned long jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  Size arg6 ;
  ZabrSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityLognormal > *)new ZabrSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,arg2,(std::vector< Real > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalSmileSection__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  ZabrSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityLognormal > *)new ZabrSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,arg2,(std::vector< Real > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalSmileSection__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  ZabrSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityLognormal > *)new ZabrSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalSmileSection__SWIG_6(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  ZabrSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityLognormal > *)new ZabrSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZabrShortMaturityLognormalSmileSection(void * jarg1) {
  ZabrSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  ext::shared_ptr< ZabrSmileSection< ZabrShortMaturityLognormal > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> > *)jarg1;
  arg1 = (ZabrSmileSection<ZabrShortMaturityLognormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalSmileSection__SWIG_0(double jarg1, double jarg2, void * jarg3, void * jarg4, unsigned long jarg5) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Size arg5 ;
  ZabrSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityNormal > *)new ZabrSmileSection< ZabrShortMaturityNormal >(arg1,arg2,(std::vector< Real > const &)*arg3,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalSmileSection__SWIG_1(double jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  ZabrSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityNormal > *)new ZabrSmileSection< ZabrShortMaturityNormal >(arg1,arg2,(std::vector< Real > const &)*arg3,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalSmileSection__SWIG_2(double jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  ZabrSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityNormal > *)new ZabrSmileSection< ZabrShortMaturityNormal >(arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalSmileSection__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned long jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  Size arg6 ;
  ZabrSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityNormal > *)new ZabrSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,arg2,(std::vector< Real > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalSmileSection__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  ZabrSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityNormal > *)new ZabrSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,arg2,(std::vector< Real > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalSmileSection__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  ZabrSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityNormal > *)new ZabrSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalSmileSection__SWIG_6(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  ZabrSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityNormal > *)new ZabrSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZabrShortMaturityNormalSmileSection(void * jarg1) {
  ZabrSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrSmileSection< ZabrShortMaturityNormal > *) 0 ;
  ext::shared_ptr< ZabrSmileSection< ZabrShortMaturityNormal > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> > *)jarg1;
  arg1 = (ZabrSmileSection<ZabrShortMaturityNormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilitySmileSection__SWIG_0(double jarg1, double jarg2, void * jarg3, void * jarg4, unsigned long jarg5) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Size arg5 ;
  ZabrSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (ZabrSmileSection< ZabrLocalVolatility > *)new ZabrSmileSection< ZabrLocalVolatility >(arg1,arg2,(std::vector< Real > const &)*arg3,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilitySmileSection__SWIG_1(double jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  ZabrSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrLocalVolatility > *)new ZabrSmileSection< ZabrLocalVolatility >(arg1,arg2,(std::vector< Real > const &)*arg3,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilitySmileSection__SWIG_2(double jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  ZabrSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrLocalVolatility > *)new ZabrSmileSection< ZabrLocalVolatility >(arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilitySmileSection__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned long jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  Size arg6 ;
  ZabrSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (ZabrSmileSection< ZabrLocalVolatility > *)new ZabrSmileSection< ZabrLocalVolatility >((Date const &)*arg1,arg2,(std::vector< Real > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilitySmileSection__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  ZabrSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrLocalVolatility > *)new ZabrSmileSection< ZabrLocalVolatility >((Date const &)*arg1,arg2,(std::vector< Real > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilitySmileSection__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  ZabrSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrLocalVolatility > *)new ZabrSmileSection< ZabrLocalVolatility >((Date const &)*arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilitySmileSection__SWIG_6(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  ZabrSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrLocalVolatility > *)new ZabrSmileSection< ZabrLocalVolatility >((Date const &)*arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZabrLocalVolatilitySmileSection(void * jarg1) {
  ZabrSmileSection< ZabrLocalVolatility > *arg1 = (ZabrSmileSection< ZabrLocalVolatility > *) 0 ;
  ext::shared_ptr< ZabrSmileSection< ZabrLocalVolatility > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> > *)jarg1;
  arg1 = (ZabrSmileSection<ZabrLocalVolatility> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdSmileSection__SWIG_0(double jarg1, double jarg2, void * jarg3, void * jarg4, unsigned long jarg5) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Size arg5 ;
  ZabrSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (ZabrSmileSection< ZabrFullFd > *)new ZabrSmileSection< ZabrFullFd >(arg1,arg2,(std::vector< Real > const &)*arg3,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdSmileSection__SWIG_1(double jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  ZabrSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrFullFd > *)new ZabrSmileSection< ZabrFullFd >(arg1,arg2,(std::vector< Real > const &)*arg3,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdSmileSection__SWIG_2(double jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  ZabrSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrFullFd > *)new ZabrSmileSection< ZabrFullFd >(arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdSmileSection__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned long jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  Size arg6 ;
  ZabrSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (ZabrSmileSection< ZabrFullFd > *)new ZabrSmileSection< ZabrFullFd >((Date const &)*arg1,arg2,(std::vector< Real > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdSmileSection__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  ZabrSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrFullFd > *)new ZabrSmileSection< ZabrFullFd >((Date const &)*arg1,arg2,(std::vector< Real > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdSmileSection__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  ZabrSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrFullFd > *)new ZabrSmileSection< ZabrFullFd >((Date const &)*arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdSmileSection__SWIG_6(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  ZabrSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrSmileSection< ZabrFullFd > *)new ZabrSmileSection< ZabrFullFd >((Date const &)*arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZabrFullFdSmileSection(void * jarg1) {
  ZabrSmileSection< ZabrFullFd > *arg1 = (ZabrSmileSection< ZabrFullFd > *) 0 ;
  ext::shared_ptr< ZabrSmileSection< ZabrFullFd > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> > *)jarg1;
  arg1 = (ZabrSmileSection<ZabrFullFd> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19, void * jarg20) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  DayCounter *arg20 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ext::shared_ptr< OptimizationMethod > tempnull19 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  arg19 = jarg19 ? (ext::shared_ptr< OptimizationMethod > *)jarg19 : &tempnull19; 
  arg20 = (DayCounter *)jarg20;
  if (!arg20) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19,(DayCounter const &)*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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ext::shared_ptr< OptimizationMethod > tempnull19 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  arg19 = jarg19 ? (ext::shared_ptr< OptimizationMethod > *)jarg19 : &tempnull19; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > 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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_2(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > 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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_3(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_4(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_5(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_6(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_7(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_8(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*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 ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_9(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*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 ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_10(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19, void * jarg20) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  DayCounter *arg20 = 0 ;
  Rate temp2 ;
  Volatility temp5 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ext::shared_ptr< OptimizationMethod > tempnull19 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  arg19 = jarg19 ? (ext::shared_ptr< OptimizationMethod > *)jarg19 : &tempnull19; 
  arg20 = (DayCounter *)jarg20;
  if (!arg20) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19,(DayCounter const &)*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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_11(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  Rate temp2 ;
  Volatility temp5 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ext::shared_ptr< OptimizationMethod > tempnull19 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  arg19 = jarg19 ? (ext::shared_ptr< OptimizationMethod > *)jarg19 : &tempnull19; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > 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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_12(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  Rate temp2 ;
  Volatility temp5 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > 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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_13(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_14(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_15(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_16(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_17(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_18(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*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 ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_19(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*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 ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZabrShortMaturityLognormalInterpolatedSmileSection_alpha(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > 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_ZabrShortMaturityLognormalInterpolatedSmileSection_beta(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > 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 double SWIGSTDCALL CSharp_QuantLib_ZabrShortMaturityLognormalInterpolatedSmileSection_nu(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *)arg1)->nu();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZabrShortMaturityLognormalInterpolatedSmileSection_rho(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZabrShortMaturityLognormalInterpolatedSmileSection_rmsError(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *)arg1)->rmsError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZabrShortMaturityLognormalInterpolatedSmileSection_maxError(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *)arg1)->maxError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_ZabrShortMaturityLognormalInterpolatedSmileSection_endCriteria(void * jarg1) {
  int jresult ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > *smartarg1 = 0 ;
  EndCriteria::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (EndCriteria::Type)((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *)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_delete_ZabrShortMaturityLognormalInterpolatedSmileSection(void * jarg1) {
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19, void * jarg20) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  DayCounter *arg20 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ext::shared_ptr< OptimizationMethod > tempnull19 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  arg19 = jarg19 ? (ext::shared_ptr< OptimizationMethod > *)jarg19 : &tempnull19; 
  arg20 = (DayCounter *)jarg20;
  if (!arg20) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19,(DayCounter const &)*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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ext::shared_ptr< OptimizationMethod > tempnull19 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  arg19 = jarg19 ? (ext::shared_ptr< OptimizationMethod > *)jarg19 : &tempnull19; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > 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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_2(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > 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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_3(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_4(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_5(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_6(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_7(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_8(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*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 ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_9(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*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 ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_10(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19, void * jarg20) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  DayCounter *arg20 = 0 ;
  Rate temp2 ;
  Volatility temp5 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ext::shared_ptr< OptimizationMethod > tempnull19 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  arg19 = jarg19 ? (ext::shared_ptr< OptimizationMethod > *)jarg19 : &tempnull19; 
  arg20 = (DayCounter *)jarg20;
  if (!arg20) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19,(DayCounter const &)*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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_11(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  Rate temp2 ;
  Volatility temp5 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ext::shared_ptr< OptimizationMethod > tempnull19 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  arg19 = jarg19 ? (ext::shared_ptr< OptimizationMethod > *)jarg19 : &tempnull19; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > 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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_12(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  Rate temp2 ;
  Volatility temp5 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > 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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_13(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_14(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_15(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_16(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_17(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_18(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*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 ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_19(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*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 ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZabrShortMaturityNormalInterpolatedSmileSection_alpha(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > 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_ZabrShortMaturityNormalInterpolatedSmileSection_beta(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > 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 double SWIGSTDCALL CSharp_QuantLib_ZabrShortMaturityNormalInterpolatedSmileSection_nu(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *)arg1)->nu();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZabrShortMaturityNormalInterpolatedSmileSection_rho(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZabrShortMaturityNormalInterpolatedSmileSection_rmsError(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *)arg1)->rmsError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZabrShortMaturityNormalInterpolatedSmileSection_maxError(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *)arg1)->maxError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_ZabrShortMaturityNormalInterpolatedSmileSection_endCriteria(void * jarg1) {
  int jresult ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > *smartarg1 = 0 ;
  EndCriteria::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (EndCriteria::Type)((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *)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_delete_ZabrShortMaturityNormalInterpolatedSmileSection(void * jarg1) {
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19, void * jarg20) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  DayCounter *arg20 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ext::shared_ptr< OptimizationMethod > tempnull19 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  arg19 = jarg19 ? (ext::shared_ptr< OptimizationMethod > *)jarg19 : &tempnull19; 
  arg20 = (DayCounter *)jarg20;
  if (!arg20) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19,(DayCounter const &)*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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ext::shared_ptr< OptimizationMethod > tempnull19 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  arg19 = jarg19 ? (ext::shared_ptr< OptimizationMethod > *)jarg19 : &tempnull19; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > 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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_2(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > 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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_3(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_4(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_5(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_6(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_7(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_8(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*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 ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_9(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*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 ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_10(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19, void * jarg20) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  DayCounter *arg20 = 0 ;
  Rate temp2 ;
  Volatility temp5 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ext::shared_ptr< OptimizationMethod > tempnull19 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  arg19 = jarg19 ? (ext::shared_ptr< OptimizationMethod > *)jarg19 : &tempnull19; 
  arg20 = (DayCounter *)jarg20;
  if (!arg20) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19,(DayCounter const &)*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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_11(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  Rate temp2 ;
  Volatility temp5 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ext::shared_ptr< OptimizationMethod > tempnull19 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  arg19 = jarg19 ? (ext::shared_ptr< OptimizationMethod > *)jarg19 : &tempnull19; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > 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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_12(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  Rate temp2 ;
  Volatility temp5 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > 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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_13(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_14(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_15(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_16(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_17(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_18(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*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 ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_19(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*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 ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZabrLocalVolatilityInterpolatedSmileSection_alpha(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *arg1 = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrLocalVolatility> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrLocalVolatility > 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_ZabrLocalVolatilityInterpolatedSmileSection_beta(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *arg1 = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrLocalVolatility> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrLocalVolatility > 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 double SWIGSTDCALL CSharp_QuantLib_ZabrLocalVolatilityInterpolatedSmileSection_nu(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *arg1 = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrLocalVolatility> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *)arg1)->nu();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZabrLocalVolatilityInterpolatedSmileSection_rho(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *arg1 = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrLocalVolatility> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZabrLocalVolatilityInterpolatedSmileSection_rmsError(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *arg1 = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrLocalVolatility> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *)arg1)->rmsError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZabrLocalVolatilityInterpolatedSmileSection_maxError(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *arg1 = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrLocalVolatility> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *)arg1)->maxError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_ZabrLocalVolatilityInterpolatedSmileSection_endCriteria(void * jarg1) {
  int jresult ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *arg1 = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > *smartarg1 = 0 ;
  EndCriteria::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrLocalVolatility> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (EndCriteria::Type)((ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *)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_delete_ZabrLocalVolatilityInterpolatedSmileSection(void * jarg1) {
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *arg1 = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrLocalVolatility> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19, void * jarg20) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  DayCounter *arg20 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ext::shared_ptr< OptimizationMethod > tempnull19 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  arg19 = jarg19 ? (ext::shared_ptr< OptimizationMethod > *)jarg19 : &tempnull19; 
  arg20 = (DayCounter *)jarg20;
  if (!arg20) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19,(DayCounter const &)*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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ext::shared_ptr< OptimizationMethod > tempnull19 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  arg19 = jarg19 ? (ext::shared_ptr< OptimizationMethod > *)jarg19 : &tempnull19; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > 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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_2(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > 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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_3(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_4(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_5(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_6(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_7(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_8(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*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 ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_9(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*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 ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_10(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19, void * jarg20) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  DayCounter *arg20 = 0 ;
  Rate temp2 ;
  Volatility temp5 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ext::shared_ptr< OptimizationMethod > tempnull19 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  arg19 = jarg19 ? (ext::shared_ptr< OptimizationMethod > *)jarg19 : &tempnull19; 
  arg20 = (DayCounter *)jarg20;
  if (!arg20) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19,(DayCounter const &)*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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_11(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18, void * jarg19) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  Rate temp2 ;
  Volatility temp5 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ext::shared_ptr< OptimizationMethod > tempnull19 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  arg19 = jarg19 ? (ext::shared_ptr< OptimizationMethod > *)jarg19 : &tempnull19; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > 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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_12(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17, void * jarg18) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  Rate temp2 ;
  Volatility temp5 ;
  ext::shared_ptr< EndCriteria > tempnull18 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  arg18 = jarg18 ? (ext::shared_ptr< EndCriteria > *)jarg18 : &tempnull18; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > 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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_13(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16, unsigned int jarg17) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_14(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, unsigned int jarg16) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_15(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_16(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_17(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12, unsigned int jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_18(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11, unsigned int jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*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 ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZabrFullFdInterpolatedSmileSection__SWIG_19(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, double jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  Rate temp2 ;
  Volatility temp5 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*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 ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZabrFullFdInterpolatedSmileSection_alpha(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *arg1 = (ZabrInterpolatedSmileSection< ZabrFullFd > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrFullFd> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrFullFd > 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_ZabrFullFdInterpolatedSmileSection_beta(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *arg1 = (ZabrInterpolatedSmileSection< ZabrFullFd > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrFullFd> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrFullFd > 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 double SWIGSTDCALL CSharp_QuantLib_ZabrFullFdInterpolatedSmileSection_nu(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *arg1 = (ZabrInterpolatedSmileSection< ZabrFullFd > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrFullFd> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrFullFd > const *)arg1)->nu();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZabrFullFdInterpolatedSmileSection_rho(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *arg1 = (ZabrInterpolatedSmileSection< ZabrFullFd > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrFullFd> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrFullFd > const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZabrFullFdInterpolatedSmileSection_rmsError(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *arg1 = (ZabrInterpolatedSmileSection< ZabrFullFd > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrFullFd> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrFullFd > const *)arg1)->rmsError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZabrFullFdInterpolatedSmileSection_maxError(void * jarg1) {
  double jresult ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *arg1 = (ZabrInterpolatedSmileSection< ZabrFullFd > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrFullFd> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrFullFd > const *)arg1)->maxError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_ZabrFullFdInterpolatedSmileSection_endCriteria(void * jarg1) {
  int jresult ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *arg1 = (ZabrInterpolatedSmileSection< ZabrFullFd > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > *smartarg1 = 0 ;
  EndCriteria::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrFullFd> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (EndCriteria::Type)((ZabrInterpolatedSmileSection< ZabrFullFd > const *)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_delete_ZabrFullFdInterpolatedSmileSection(void * jarg1) {
  ZabrInterpolatedSmileSection< ZabrFullFd > *arg1 = (ZabrInterpolatedSmileSection< ZabrFullFd > *) 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *)jarg1;
  arg1 = (ZabrInterpolatedSmileSection<ZabrFullFd> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrSmileSection__SWIG_0(double jarg1, double jarg2, void * jarg3, double jarg4, int jarg5) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  VolatilityType arg5 ;
  NoArbSabrSmileSection *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (VolatilityType)jarg5; 
  {
    try {
      result = (NoArbSabrSmileSection *)new NoArbSabrSmileSection(arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  NoArbSabrSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrSmileSection__SWIG_1(double jarg1, double jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  Real arg4 ;
  NoArbSabrSmileSection *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (NoArbSabrSmileSection *)new NoArbSabrSmileSection(arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  NoArbSabrSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrSmileSection__SWIG_2(double jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  NoArbSabrSmileSection *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (NoArbSabrSmileSection *)new NoArbSabrSmileSection(arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  NoArbSabrSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrSmileSection__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, int jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Real arg5 ;
  VolatilityType arg6 ;
  NoArbSabrSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (VolatilityType)jarg6; 
  {
    try {
      result = (NoArbSabrSmileSection *)new NoArbSabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  NoArbSabrSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrSmileSection__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Real arg5 ;
  NoArbSabrSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (NoArbSabrSmileSection *)new NoArbSabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  NoArbSabrSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrSmileSection__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  NoArbSabrSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (NoArbSabrSmileSection *)new NoArbSabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  NoArbSabrSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrSmileSection__SWIG_6(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real > *arg3 = 0 ;
  NoArbSabrSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (NoArbSabrSmileSection *)new NoArbSabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real > 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 ? new ext::shared_ptr<  NoArbSabrSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NoArbSabrSmileSection(void * jarg1) {
  NoArbSabrSmileSection *arg1 = (NoArbSabrSmileSection *) 0 ;
  ext::shared_ptr< NoArbSabrSmileSection > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  NoArbSabrSmileSection > *)jarg1;
  arg1 = (NoArbSabrSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, void * jarg16, void * jarg17, void * jarg18) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  ext::shared_ptr< EndCriteria > *arg16 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg17 = 0 ;
  DayCounter *arg18 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull16 ;
  ext::shared_ptr< OptimizationMethod > tempnull17 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? (ext::shared_ptr< EndCriteria > *)jarg16 : &tempnull16; 
  arg17 = jarg17 ? (ext::shared_ptr< OptimizationMethod > *)jarg17 : &tempnull17; 
  arg18 = (DayCounter *)jarg18;
  if (!arg18) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,(ext::shared_ptr< EndCriteria > const &)*arg16,(ext::shared_ptr< OptimizationMethod > const &)*arg17,(DayCounter 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 = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, void * jarg16, void * jarg17) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  ext::shared_ptr< EndCriteria > *arg16 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg17 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull16 ;
  ext::shared_ptr< OptimizationMethod > tempnull17 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? (ext::shared_ptr< EndCriteria > *)jarg16 : &tempnull16; 
  arg17 = jarg17 ? (ext::shared_ptr< OptimizationMethod > *)jarg17 : &tempnull17; 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,(ext::shared_ptr< EndCriteria > const &)*arg16,(ext::shared_ptr< OptimizationMethod > 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 = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_2(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, void * jarg16) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  ext::shared_ptr< EndCriteria > *arg16 = 0 ;
  ext::shared_ptr< EndCriteria > tempnull16 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? (ext::shared_ptr< EndCriteria > *)jarg16 : &tempnull16; 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,(ext::shared_ptr< EndCriteria > 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 = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_3(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_4(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_5(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_6(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11, unsigned int jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*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 ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_7(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > const &)*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 ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_8(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Handle< Quote > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote > > 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 = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_9(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, void * jarg16, void * jarg17, void * jarg18) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  ext::shared_ptr< EndCriteria > *arg16 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg17 = 0 ;
  DayCounter *arg18 = 0 ;
  Rate temp2 ;
  Volatility temp5 ;
  ext::shared_ptr< EndCriteria > tempnull16 ;
  ext::shared_ptr< OptimizationMethod > tempnull17 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? (ext::shared_ptr< EndCriteria > *)jarg16 : &tempnull16; 
  arg17 = jarg17 ? (ext::shared_ptr< OptimizationMethod > *)jarg17 : &tempnull17; 
  arg18 = (DayCounter *)jarg18;
  if (!arg18) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,(ext::shared_ptr< EndCriteria > const &)*arg16,(ext::shared_ptr< OptimizationMethod > const &)*arg17,(DayCounter 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 = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_10(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, void * jarg16, void * jarg17) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  ext::shared_ptr< EndCriteria > *arg16 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg17 = 0 ;
  Rate temp2 ;
  Volatility temp5 ;
  ext::shared_ptr< EndCriteria > tempnull16 ;
  ext::shared_ptr< OptimizationMethod > tempnull17 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? (ext::shared_ptr< EndCriteria > *)jarg16 : &tempnull16; 
  arg17 = jarg17 ? (ext::shared_ptr< OptimizationMethod > *)jarg17 : &tempnull17; 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,(ext::shared_ptr< EndCriteria > const &)*arg16,(ext::shared_ptr< OptimizationMethod > 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 = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_11(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15, void * jarg16) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  ext::shared_ptr< EndCriteria > *arg16 = 0 ;
  Rate temp2 ;
  Volatility temp5 ;
  ext::shared_ptr< EndCriteria > tempnull16 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  arg16 = jarg16 ? (ext::shared_ptr< EndCriteria > *)jarg16 : &tempnull16; 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,(ext::shared_ptr< EndCriteria > 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 = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_12(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, unsigned int jarg15) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  Rate temp2 ;
  Volatility temp5 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_13(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  Rate temp2 ;
  Volatility temp5 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_14(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11, unsigned int jarg12, unsigned int jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  Rate temp2 ;
  Volatility temp5 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*arg6,arg7,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 = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_15(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11, unsigned int jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  Rate temp2 ;
  Volatility temp5 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*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 ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_16(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  Rate temp2 ;
  Volatility temp5 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > const &)*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 ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoArbSabrInterpolatedSmileSection__SWIG_17(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, double jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Rate temp2 ;
  Volatility temp5 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  temp2 = (Rate)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  temp5 = (Volatility)jarg5; 
  arg5 = &temp5; 
  arg6 = (std::vector< Volatility > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility > 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 = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_NoArbSabrInterpolatedSmileSection_alpha(void * jarg1) {
  double jresult ;
  NoArbSabrInterpolatedSmileSection *arg1 = (NoArbSabrInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > *)jarg1;
  arg1 = (NoArbSabrInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((NoArbSabrInterpolatedSmileSection 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_NoArbSabrInterpolatedSmileSection_beta(void * jarg1) {
  double jresult ;
  NoArbSabrInterpolatedSmileSection *arg1 = (NoArbSabrInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > *)jarg1;
  arg1 = (NoArbSabrInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((NoArbSabrInterpolatedSmileSection 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 double SWIGSTDCALL CSharp_QuantLib_NoArbSabrInterpolatedSmileSection_nu(void * jarg1) {
  double jresult ;
  NoArbSabrInterpolatedSmileSection *arg1 = (NoArbSabrInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > *)jarg1;
  arg1 = (NoArbSabrInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((NoArbSabrInterpolatedSmileSection const *)arg1)->nu();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_NoArbSabrInterpolatedSmileSection_rho(void * jarg1) {
  double jresult ;
  NoArbSabrInterpolatedSmileSection *arg1 = (NoArbSabrInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > *)jarg1;
  arg1 = (NoArbSabrInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((NoArbSabrInterpolatedSmileSection const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_NoArbSabrInterpolatedSmileSection_rmsError(void * jarg1) {
  double jresult ;
  NoArbSabrInterpolatedSmileSection *arg1 = (NoArbSabrInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > *)jarg1;
  arg1 = (NoArbSabrInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((NoArbSabrInterpolatedSmileSection const *)arg1)->rmsError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_NoArbSabrInterpolatedSmileSection_maxError(void * jarg1) {
  double jresult ;
  NoArbSabrInterpolatedSmileSection *arg1 = (NoArbSabrInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > *)jarg1;
  arg1 = (NoArbSabrInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((NoArbSabrInterpolatedSmileSection const *)arg1)->maxError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_NoArbSabrInterpolatedSmileSection_endCriteria(void * jarg1) {
  int jresult ;
  NoArbSabrInterpolatedSmileSection *arg1 = (NoArbSabrInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > *smartarg1 = 0 ;
  EndCriteria::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > *)jarg1;
  arg1 = (NoArbSabrInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (EndCriteria::Type)((NoArbSabrInterpolatedSmileSection const *)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_delete_NoArbSabrInterpolatedSmileSection(void * jarg1) {
  NoArbSabrInterpolatedSmileSection *arg1 = (NoArbSabrInterpolatedSmileSection *) 0 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *)jarg1;
  arg1 = (NoArbSabrInterpolatedSmileSection *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_sabrVolatility__SWIG_0(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, int jarg8) {
  double jresult ;
  Rate arg1 ;
  Rate arg2 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  VolatilityType arg8 ;
  Real result;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (VolatilityType)jarg8; 
  {
    try {
      result = (Real)sabrVolatility(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_sabrVolatility__SWIG_1(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7) {
  double jresult ;
  Rate arg1 ;
  Rate arg2 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real result;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (Real)sabrVolatility(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_shiftedSabrVolatility__SWIG_0(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, int jarg9) {
  double jresult ;
  Rate arg1 ;
  Rate arg2 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  VolatilityType arg9 ;
  Real result;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (VolatilityType)jarg9; 
  {
    try {
      result = (Real)shiftedSabrVolatility(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_shiftedSabrVolatility__SWIG_1(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8) {
  double jresult ;
  Rate arg1 ;
  Rate arg2 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  Real result;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (Real)shiftedSabrVolatility(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_sabrFlochKennedyVolatility(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7) {
  double jresult ;
  Rate arg1 ;
  Rate arg2 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real result;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (Real)sabrFlochKennedyVolatility(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 void * SWIGSTDCALL CSharp_QuantLib_new_CalibrationErrorTuple(double jarg1, double jarg2, double jarg3) {
  void * jresult ;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  ext::tuple< Real,Real,Real > *result = 0 ;
  
  arg1 = (double)jarg1; 
  arg2 = (double)jarg2; 
  arg3 = (double)jarg3; 
  {
    try {
      result = (ext::tuple< Real,Real,Real > *)new ext::tuple< Real,Real,Real >(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_CalibrationErrorTuple_first(void * jarg1) {
  double jresult ;
  ext::tuple< Real,Real,Real > *arg1 = (ext::tuple< Real,Real,Real > *) 0 ;
  double result;
  
  arg1 = (ext::tuple< Real,Real,Real > *)jarg1; 
  {
    try {
      result = (double)ext_tuple_Sl_Real_Sc_Real_Sc_Real_Sg__first((ext::tuple< double,double,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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CalibrationErrorTuple_second(void * jarg1) {
  double jresult ;
  ext::tuple< Real,Real,Real > *arg1 = (ext::tuple< Real,Real,Real > *) 0 ;
  double result;
  
  arg1 = (ext::tuple< Real,Real,Real > *)jarg1; 
  {
    try {
      result = (double)ext_tuple_Sl_Real_Sc_Real_Sc_Real_Sg__second((ext::tuple< double,double,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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CalibrationErrorTuple_third(void * jarg1) {
  double jresult ;
  ext::tuple< Real,Real,Real > *arg1 = (ext::tuple< Real,Real,Real > *) 0 ;
  double result;
  
  arg1 = (ext::tuple< Real,Real,Real > *)jarg1; 
  {
    try {
      result = (double)ext_tuple_Sl_Real_Sc_Real_Sc_Real_Sg__third((ext::tuple< double,double,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 = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CalibrationErrorTuple(void * jarg1) {
  ext::tuple< Real,Real,Real > *arg1 = (ext::tuple< Real,Real,Real > *) 0 ;
  
  arg1 = (ext::tuple< Real,Real,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_AndreasenHugeVolatilityInterpl__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, unsigned long jarg7, double jarg8, double jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  AndreasenHugeVolatilityInterpl::CalibrationSet *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  AndreasenHugeVolatilityInterpl::InterpolationType arg5 ;
  AndreasenHugeVolatilityInterpl::CalibrationType arg6 ;
  Size arg7 ;
  Real arg8 ;
  Real arg9 ;
  ext::shared_ptr< OptimizationMethod > *arg10 = 0 ;
  EndCriteria *arg11 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempnull10 ;
  AndreasenHugeVolatilityInterpl *result = 0 ;
  
  arg1 = (AndreasenHugeVolatilityInterpl::CalibrationSet *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "AndreasenHugeVolatilityInterpl::CalibrationSet const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (AndreasenHugeVolatilityInterpl::InterpolationType)jarg5; 
  arg6 = (AndreasenHugeVolatilityInterpl::CalibrationType)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = jarg10 ? (ext::shared_ptr< OptimizationMethod > *)jarg10 : &tempnull10; 
  
  arg11 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg11) ? ((ext::shared_ptr< const EndCriteria > *)jarg11)->get() : 0);
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (AndreasenHugeVolatilityInterpl *)new AndreasenHugeVolatilityInterpl((AndreasenHugeVolatilityInterpl::CalibrationSet const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< YieldTermStructure > const &)*arg4,arg5,arg6,arg7,arg8,arg9,(ext::shared_ptr< OptimizationMethod > const &)*arg10,(EndCriteria 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 = result ? new ext::shared_ptr<  AndreasenHugeVolatilityInterpl >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AndreasenHugeVolatilityInterpl__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, unsigned long jarg7, double jarg8, double jarg9, void * jarg10) {
  void * jresult ;
  AndreasenHugeVolatilityInterpl::CalibrationSet *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  AndreasenHugeVolatilityInterpl::InterpolationType arg5 ;
  AndreasenHugeVolatilityInterpl::CalibrationType arg6 ;
  Size arg7 ;
  Real arg8 ;
  Real arg9 ;
  ext::shared_ptr< OptimizationMethod > *arg10 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempnull10 ;
  AndreasenHugeVolatilityInterpl *result = 0 ;
  
  arg1 = (AndreasenHugeVolatilityInterpl::CalibrationSet *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "AndreasenHugeVolatilityInterpl::CalibrationSet const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (AndreasenHugeVolatilityInterpl::InterpolationType)jarg5; 
  arg6 = (AndreasenHugeVolatilityInterpl::CalibrationType)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = jarg10 ? (ext::shared_ptr< OptimizationMethod > *)jarg10 : &tempnull10; 
  {
    try {
      result = (AndreasenHugeVolatilityInterpl *)new AndreasenHugeVolatilityInterpl((AndreasenHugeVolatilityInterpl::CalibrationSet const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< YieldTermStructure > const &)*arg4,arg5,arg6,arg7,arg8,arg9,(ext::shared_ptr< OptimizationMethod > 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 = result ? new ext::shared_ptr<  AndreasenHugeVolatilityInterpl >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AndreasenHugeVolatilityInterpl__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, unsigned long jarg7, double jarg8, double jarg9) {
  void * jresult ;
  AndreasenHugeVolatilityInterpl::CalibrationSet *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  AndreasenHugeVolatilityInterpl::InterpolationType arg5 ;
  AndreasenHugeVolatilityInterpl::CalibrationType arg6 ;
  Size arg7 ;
  Real arg8 ;
  Real arg9 ;
  AndreasenHugeVolatilityInterpl *result = 0 ;
  
  arg1 = (AndreasenHugeVolatilityInterpl::CalibrationSet *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "AndreasenHugeVolatilityInterpl::CalibrationSet const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (AndreasenHugeVolatilityInterpl::InterpolationType)jarg5; 
  arg6 = (AndreasenHugeVolatilityInterpl::CalibrationType)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (AndreasenHugeVolatilityInterpl *)new AndreasenHugeVolatilityInterpl((AndreasenHugeVolatilityInterpl::CalibrationSet const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< YieldTermStructure > 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 ? new ext::shared_ptr<  AndreasenHugeVolatilityInterpl >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AndreasenHugeVolatilityInterpl__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, unsigned long jarg7, double jarg8) {
  void * jresult ;
  AndreasenHugeVolatilityInterpl::CalibrationSet *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  AndreasenHugeVolatilityInterpl::InterpolationType arg5 ;
  AndreasenHugeVolatilityInterpl::CalibrationType arg6 ;
  Size arg7 ;
  Real arg8 ;
  AndreasenHugeVolatilityInterpl *result = 0 ;
  
  arg1 = (AndreasenHugeVolatilityInterpl::CalibrationSet *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "AndreasenHugeVolatilityInterpl::CalibrationSet const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (AndreasenHugeVolatilityInterpl::InterpolationType)jarg5; 
  arg6 = (AndreasenHugeVolatilityInterpl::CalibrationType)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (AndreasenHugeVolatilityInterpl *)new AndreasenHugeVolatilityInterpl((AndreasenHugeVolatilityInterpl::CalibrationSet const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< YieldTermStructure > 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 ? new ext::shared_ptr<  AndreasenHugeVolatilityInterpl >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AndreasenHugeVolatilityInterpl__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, unsigned long jarg7) {
  void * jresult ;
  AndreasenHugeVolatilityInterpl::CalibrationSet *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  AndreasenHugeVolatilityInterpl::InterpolationType arg5 ;
  AndreasenHugeVolatilityInterpl::CalibrationType arg6 ;
  Size arg7 ;
  AndreasenHugeVolatilityInterpl *result = 0 ;
  
  arg1 = (AndreasenHugeVolatilityInterpl::CalibrationSet *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "AndreasenHugeVolatilityInterpl::CalibrationSet const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (AndreasenHugeVolatilityInterpl::InterpolationType)jarg5; 
  arg6 = (AndreasenHugeVolatilityInterpl::CalibrationType)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (AndreasenHugeVolatilityInterpl *)new AndreasenHugeVolatilityInterpl((AndreasenHugeVolatilityInterpl::CalibrationSet const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< YieldTermStructure > 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 ? new ext::shared_ptr<  AndreasenHugeVolatilityInterpl >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AndreasenHugeVolatilityInterpl__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  void * jresult ;
  AndreasenHugeVolatilityInterpl::CalibrationSet *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  AndreasenHugeVolatilityInterpl::InterpolationType arg5 ;
  AndreasenHugeVolatilityInterpl::CalibrationType arg6 ;
  AndreasenHugeVolatilityInterpl *result = 0 ;
  
  arg1 = (AndreasenHugeVolatilityInterpl::CalibrationSet *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "AndreasenHugeVolatilityInterpl::CalibrationSet const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (AndreasenHugeVolatilityInterpl::InterpolationType)jarg5; 
  arg6 = (AndreasenHugeVolatilityInterpl::CalibrationType)jarg6; 
  {
    try {
      result = (AndreasenHugeVolatilityInterpl *)new AndreasenHugeVolatilityInterpl((AndreasenHugeVolatilityInterpl::CalibrationSet const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< YieldTermStructure > 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 ? new ext::shared_ptr<  AndreasenHugeVolatilityInterpl >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AndreasenHugeVolatilityInterpl__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  AndreasenHugeVolatilityInterpl::CalibrationSet *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  AndreasenHugeVolatilityInterpl::InterpolationType arg5 ;
  AndreasenHugeVolatilityInterpl *result = 0 ;
  
  arg1 = (AndreasenHugeVolatilityInterpl::CalibrationSet *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "AndreasenHugeVolatilityInterpl::CalibrationSet const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (AndreasenHugeVolatilityInterpl::InterpolationType)jarg5; 
  {
    try {
      result = (AndreasenHugeVolatilityInterpl *)new AndreasenHugeVolatilityInterpl((AndreasenHugeVolatilityInterpl::CalibrationSet const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*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 = result ? new ext::shared_ptr<  AndreasenHugeVolatilityInterpl >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AndreasenHugeVolatilityInterpl__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  AndreasenHugeVolatilityInterpl::CalibrationSet *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  AndreasenHugeVolatilityInterpl *result = 0 ;
  
  arg1 = (AndreasenHugeVolatilityInterpl::CalibrationSet *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "AndreasenHugeVolatilityInterpl::CalibrationSet const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AndreasenHugeVolatilityInterpl *)new AndreasenHugeVolatilityInterpl((AndreasenHugeVolatilityInterpl::CalibrationSet const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*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 ? new ext::shared_ptr<  AndreasenHugeVolatilityInterpl >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AndreasenHugeVolatilityInterpl_maxDate(void * jarg1) {
  void * jresult ;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const AndreasenHugeVolatilityInterpl > *)jarg1;
  arg1 = (AndreasenHugeVolatilityInterpl *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((AndreasenHugeVolatilityInterpl const *)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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_AndreasenHugeVolatilityInterpl_minStrike(void * jarg1) {
  double jresult ;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const AndreasenHugeVolatilityInterpl > *)jarg1;
  arg1 = (AndreasenHugeVolatilityInterpl *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((AndreasenHugeVolatilityInterpl const *)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_AndreasenHugeVolatilityInterpl_maxStrike(void * jarg1) {
  double jresult ;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const AndreasenHugeVolatilityInterpl > *)jarg1;
  arg1 = (AndreasenHugeVolatilityInterpl *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((AndreasenHugeVolatilityInterpl const *)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_AndreasenHugeVolatilityInterpl_fwd(void * jarg1, double jarg2) {
  double jresult ;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  Time arg2 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const AndreasenHugeVolatilityInterpl > *)jarg1;
  arg1 = (AndreasenHugeVolatilityInterpl *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)((AndreasenHugeVolatilityInterpl const *)arg1)->fwd(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AndreasenHugeVolatilityInterpl_riskFreeRate(void * jarg1) {
  void * jresult ;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > *smartarg1 = 0 ;
  Handle< YieldTermStructure > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const AndreasenHugeVolatilityInterpl > *)jarg1;
  arg1 = (AndreasenHugeVolatilityInterpl *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Handle< YieldTermStructure > *) &((AndreasenHugeVolatilityInterpl const *)arg1)->riskFreeRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AndreasenHugeVolatilityInterpl_calibrationError(void * jarg1) {
  void * jresult ;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > *smartarg1 = 0 ;
  SwigValueWrapper< ext::tuple< double,double,double > > result;
  
  
  smartarg1 = (ext::shared_ptr< const AndreasenHugeVolatilityInterpl > *)jarg1;
  arg1 = (AndreasenHugeVolatilityInterpl *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((AndreasenHugeVolatilityInterpl const *)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 = new ext::tuple< Real,Real,Real >(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_AndreasenHugeVolatilityInterpl_optionPrice(void * jarg1, double jarg2, double jarg3, int jarg4) {
  double jresult ;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Option::Type arg4 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const AndreasenHugeVolatilityInterpl > *)jarg1;
  arg1 = (AndreasenHugeVolatilityInterpl *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Option::Type)jarg4; 
  {
    try {
      result = (Real)((AndreasenHugeVolatilityInterpl const *)arg1)->optionPrice(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_AndreasenHugeVolatilityInterpl_localVol(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  Time arg2 ;
  Real arg3 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const AndreasenHugeVolatilityInterpl > *)jarg1;
  arg1 = (AndreasenHugeVolatilityInterpl *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Volatility)((AndreasenHugeVolatilityInterpl const *)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_delete_AndreasenHugeVolatilityInterpl(void * jarg1) {
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AndreasenHugeVolatilityInterpl > *)jarg1;
  arg1 = (AndreasenHugeVolatilityInterpl *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AndreasenHugeVolatilityAdapter__SWIG_0(void * jarg1, double jarg2) {
  void * jresult ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl > *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl > tempnull1 ;
  AndreasenHugeVolatilityAdapter *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< AndreasenHugeVolatilityInterpl > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (AndreasenHugeVolatilityAdapter *)new AndreasenHugeVolatilityAdapter((ext::shared_ptr< AndreasenHugeVolatilityInterpl > 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 ? new ext::shared_ptr<  AndreasenHugeVolatilityAdapter >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AndreasenHugeVolatilityAdapter__SWIG_1(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl > *arg1 = 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl > tempnull1 ;
  AndreasenHugeVolatilityAdapter *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< AndreasenHugeVolatilityInterpl > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AndreasenHugeVolatilityAdapter *)new AndreasenHugeVolatilityAdapter((ext::shared_ptr< AndreasenHugeVolatilityInterpl > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AndreasenHugeVolatilityAdapter >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AndreasenHugeVolatilityAdapter(void * jarg1) {
  AndreasenHugeVolatilityAdapter *arg1 = (AndreasenHugeVolatilityAdapter *) 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityAdapter > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AndreasenHugeVolatilityAdapter > *)jarg1;
  arg1 = (AndreasenHugeVolatilityAdapter *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AndreasenHugeLocalVolAdapter(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl > *arg1 = 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl > tempnull1 ;
  AndreasenHugeLocalVolAdapter *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< AndreasenHugeVolatilityInterpl > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AndreasenHugeLocalVolAdapter *)new AndreasenHugeLocalVolAdapter((ext::shared_ptr< AndreasenHugeVolatilityInterpl > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AndreasenHugeLocalVolAdapter >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AndreasenHugeLocalVolAdapter(void * jarg1) {
  AndreasenHugeLocalVolAdapter *arg1 = (AndreasenHugeLocalVolAdapter *) 0 ;
  ext::shared_ptr< AndreasenHugeLocalVolAdapter > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AndreasenHugeLocalVolAdapter > *)jarg1;
  arg1 = (AndreasenHugeLocalVolAdapter *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HestonBlackVolSurface__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
  void * jresult ;
  Handle< HestonModel > *arg1 = 0 ;
  AnalyticHestonEngine::ComplexLogFormula arg2 ;
  AnalyticHestonEngine::Integration *arg3 = 0 ;
  HestonBlackVolSurface *result = 0 ;
  
  arg1 = (Handle< HestonModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< HestonModel > const & is null", 0);
    return 0;
  } 
  arg2 = (AnalyticHestonEngine::ComplexLogFormula)jarg2; 
  arg3 = (AnalyticHestonEngine::Integration *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "AnalyticHestonEngine::Integration const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (HestonBlackVolSurface *)new HestonBlackVolSurface((Handle< HestonModel > const &)*arg1,arg2,(AnalyticHestonEngine::Integration 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 ? new ext::shared_ptr<  HestonBlackVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HestonBlackVolSurface__SWIG_1(void * jarg1, int jarg2) {
  void * jresult ;
  Handle< HestonModel > *arg1 = 0 ;
  AnalyticHestonEngine::ComplexLogFormula arg2 ;
  HestonBlackVolSurface *result = 0 ;
  
  arg1 = (Handle< HestonModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< HestonModel > const & is null", 0);
    return 0;
  } 
  arg2 = (AnalyticHestonEngine::ComplexLogFormula)jarg2; 
  {
    try {
      result = (HestonBlackVolSurface *)new HestonBlackVolSurface((Handle< HestonModel > 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 ? new ext::shared_ptr<  HestonBlackVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HestonBlackVolSurface__SWIG_2(void * jarg1) {
  void * jresult ;
  Handle< HestonModel > *arg1 = 0 ;
  HestonBlackVolSurface *result = 0 ;
  
  arg1 = (Handle< HestonModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< HestonModel > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (HestonBlackVolSurface *)new HestonBlackVolSurface((Handle< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  HestonBlackVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HestonBlackVolSurface(void * jarg1) {
  HestonBlackVolSurface *arg1 = (HestonBlackVolSurface *) 0 ;
  ext::shared_ptr< HestonBlackVolSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  HestonBlackVolSurface > *)jarg1;
  arg1 = (HestonBlackVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsMarket(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  std::vector< Period > *arg1 = 0 ;
  std::vector< ext::shared_ptr< SwapIndex > > *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  std::vector< std::vector< Handle< Quote > > > *arg4 = 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  CmsMarket *result = 0 ;
  
  arg1 = (std::vector< Period > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< SwapIndex > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< SwapIndex > > const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (std::vector< std::vector< Handle< Quote > > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Handle< Quote > > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CmsCouponPricer > > const & is null", 0);
    return 0;
  } 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsMarket *)new CmsMarket((std::vector< Period > const &)*arg1,(std::vector< ext::shared_ptr< SwapIndex > > const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(std::vector< std::vector< Handle< Quote > > > const &)*arg4,(std::vector< ext::shared_ptr< CmsCouponPricer > > 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 = result ? new ext::shared_ptr<  CmsMarket >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CmsMarket_reprice(void * jarg1, void * jarg2, double jarg3) {
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  Handle< SwaptionVolatilityStructure > *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CmsMarket > *)jarg1;
  arg1 = (CmsMarket *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Handle< SwaptionVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return ;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      (arg1)->reprice((Handle< SwaptionVolatilityStructure > 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_CmsMarket_swapTenors(void * jarg1) {
  void * jresult ;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  ext::shared_ptr< CmsMarket const > *smartarg1 = 0 ;
  std::vector< Period > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const CmsMarket > *)jarg1;
  arg1 = (CmsMarket *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Period > *) &((CmsMarket const *)arg1)->swapTenors();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsMarket_swapLengths(void * jarg1) {
  void * jresult ;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  ext::shared_ptr< CmsMarket const > *smartarg1 = 0 ;
  std::vector< Period > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const CmsMarket > *)jarg1;
  arg1 = (CmsMarket *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Period > *) &((CmsMarket const *)arg1)->swapLengths();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsMarket_impliedCmsSpreads(void * jarg1) {
  void * jresult ;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  Matrix *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CmsMarket > *)jarg1;
  arg1 = (CmsMarket *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Matrix *) &(arg1)->impliedCmsSpreads();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsMarket_spreadErrors(void * jarg1) {
  void * jresult ;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  Matrix *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CmsMarket > *)jarg1;
  arg1 = (CmsMarket *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Matrix *) &(arg1)->spreadErrors();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsMarket_browse(void * jarg1) {
  void * jresult ;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  ext::shared_ptr< CmsMarket const > *smartarg1 = 0 ;
  Matrix result;
  
  
  smartarg1 = (ext::shared_ptr< const CmsMarket > *)jarg1;
  arg1 = (CmsMarket *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((CmsMarket const *)arg1)->browse();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CmsMarket_weightedSpreadError(void * jarg1, void * jarg2) {
  double jresult ;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  Matrix *arg2 = 0 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CmsMarket > *)jarg1;
  arg1 = (CmsMarket *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Matrix *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(arg1)->weightedSpreadError((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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CmsMarket_weightedSpotNpvError(void * jarg1, void * jarg2) {
  double jresult ;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  Matrix *arg2 = 0 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CmsMarket > *)jarg1;
  arg1 = (CmsMarket *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Matrix *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(arg1)->weightedSpotNpvError((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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CmsMarket_weightedFwdNpvError(void * jarg1, void * jarg2) {
  double jresult ;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  Matrix *arg2 = 0 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CmsMarket > *)jarg1;
  arg1 = (CmsMarket *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Matrix *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(arg1)->weightedFwdNpvError((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 = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsMarket_weightedSpreadErrors(void * jarg1, void * jarg2) {
  void * jresult ;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  Matrix *arg2 = 0 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr<  CmsMarket > *)jarg1;
  arg1 = (CmsMarket *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Matrix *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (arg1)->weightedSpreadErrors((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 Array(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsMarket_weightedSpotNpvErrors(void * jarg1, void * jarg2) {
  void * jresult ;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  Matrix *arg2 = 0 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr<  CmsMarket > *)jarg1;
  arg1 = (CmsMarket *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Matrix *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (arg1)->weightedSpotNpvErrors((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 Array(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsMarket_weightedFwdNpvErrors(void * jarg1, void * jarg2) {
  void * jresult ;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  Matrix *arg2 = 0 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr<  CmsMarket > *)jarg1;
  arg1 = (CmsMarket *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Matrix *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (arg1)->weightedFwdNpvErrors((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 Array(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CmsMarket(void * jarg1) {
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CmsMarket > *)jarg1;
  arg1 = (CmsMarket *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsMarketCalibration(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  ext::shared_ptr< CmsMarket > *arg2 = 0 ;
  Matrix *arg3 = 0 ;
  CmsMarketCalibration::CalibrationType arg4 ;
  ext::shared_ptr< CmsMarket > tempnull2 ;
  CmsMarketCalibration *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< CmsMarket > *)jarg2 : &tempnull2; 
  arg3 = (Matrix *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg4 = (CmsMarketCalibration::CalibrationType)jarg4; 
  {
    try {
      result = (CmsMarketCalibration *)new CmsMarketCalibration(*arg1,*arg2,(Matrix 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_CmsMarketCalibration_compute__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned int jarg5) {
  void * jresult ;
  CmsMarketCalibration *arg1 = (CmsMarketCalibration *) 0 ;
  ext::shared_ptr< EndCriteria > *arg2 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg3 = 0 ;
  Array *arg4 = 0 ;
  bool arg5 ;
  ext::shared_ptr< EndCriteria > tempnull2 ;
  ext::shared_ptr< OptimizationMethod > tempnull3 ;
  Array result;
  
  arg1 = (CmsMarketCalibration *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< EndCriteria > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< OptimizationMethod > *)jarg3 : &tempnull3; 
  arg4 = (Array *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (arg1)->compute((ext::shared_ptr< EndCriteria > const &)*arg2,(ext::shared_ptr< OptimizationMethod > const &)*arg3,(Array 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 Array(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsMarketCalibration_compute__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned int jarg5, double jarg6) {
  void * jresult ;
  CmsMarketCalibration *arg1 = (CmsMarketCalibration *) 0 ;
  ext::shared_ptr< EndCriteria > *arg2 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg3 = 0 ;
  Matrix *arg4 = 0 ;
  bool arg5 ;
  Real arg6 ;
  ext::shared_ptr< EndCriteria > tempnull2 ;
  ext::shared_ptr< OptimizationMethod > tempnull3 ;
  Matrix result;
  
  arg1 = (CmsMarketCalibration *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< EndCriteria > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< OptimizationMethod > *)jarg3 : &tempnull3; 
  arg4 = (Matrix *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (arg1)->compute((ext::shared_ptr< EndCriteria > const &)*arg2,(ext::shared_ptr< OptimizationMethod > const &)*arg3,(Matrix 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 Matrix(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsMarketCalibration_compute__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned int jarg5) {
  void * jresult ;
  CmsMarketCalibration *arg1 = (CmsMarketCalibration *) 0 ;
  ext::shared_ptr< EndCriteria > *arg2 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg3 = 0 ;
  Matrix *arg4 = 0 ;
  bool arg5 ;
  ext::shared_ptr< EndCriteria > tempnull2 ;
  ext::shared_ptr< OptimizationMethod > tempnull3 ;
  Matrix result;
  
  arg1 = (CmsMarketCalibration *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< EndCriteria > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< OptimizationMethod > *)jarg3 : &tempnull3; 
  arg4 = (Matrix *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (arg1)->compute((ext::shared_ptr< EndCriteria > const &)*arg2,(ext::shared_ptr< OptimizationMethod > const &)*arg3,(Matrix 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 Matrix(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsMarketCalibration_computeParametric__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned int jarg5, double jarg6) {
  void * jresult ;
  CmsMarketCalibration *arg1 = (CmsMarketCalibration *) 0 ;
  ext::shared_ptr< EndCriteria > *arg2 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg3 = 0 ;
  Matrix *arg4 = 0 ;
  bool arg5 ;
  Real arg6 ;
  ext::shared_ptr< EndCriteria > tempnull2 ;
  ext::shared_ptr< OptimizationMethod > tempnull3 ;
  Matrix result;
  
  arg1 = (CmsMarketCalibration *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< EndCriteria > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< OptimizationMethod > *)jarg3 : &tempnull3; 
  arg4 = (Matrix *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (arg1)->computeParametric((ext::shared_ptr< EndCriteria > const &)*arg2,(ext::shared_ptr< OptimizationMethod > const &)*arg3,(Matrix 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 Matrix(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsMarketCalibration_computeParametric__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned int jarg5) {
  void * jresult ;
  CmsMarketCalibration *arg1 = (CmsMarketCalibration *) 0 ;
  ext::shared_ptr< EndCriteria > *arg2 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg3 = 0 ;
  Matrix *arg4 = 0 ;
  bool arg5 ;
  ext::shared_ptr< EndCriteria > tempnull2 ;
  ext::shared_ptr< OptimizationMethod > tempnull3 ;
  Matrix result;
  
  arg1 = (CmsMarketCalibration *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< EndCriteria > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< OptimizationMethod > *)jarg3 : &tempnull3; 
  arg4 = (Matrix *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (arg1)->computeParametric((ext::shared_ptr< EndCriteria > const &)*arg2,(ext::shared_ptr< OptimizationMethod > const &)*arg3,(Matrix 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 Matrix(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CmsMarketCalibration_error(void * jarg1) {
  double jresult ;
  CmsMarketCalibration *arg1 = (CmsMarketCalibration *) 0 ;
  Real result;
  
  arg1 = (CmsMarketCalibration *)jarg1; 
  {
    try {
      result = (Real)(arg1)->error();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_CmsMarketCalibration_endCriteria(void * jarg1) {
  int jresult ;
  CmsMarketCalibration *arg1 = (CmsMarketCalibration *) 0 ;
  EndCriteria::Type result;
  
  arg1 = (CmsMarketCalibration *)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_delete_CmsMarketCalibration(void * jarg1) {
  CmsMarketCalibration *arg1 = (CmsMarketCalibration *) 0 ;
  
  arg1 = (CmsMarketCalibration *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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 ;
  CashFlow *arg1 = (CashFlow *) 0 ;
  ext::shared_ptr< CashFlow const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const CashFlow > *)jarg1;
  arg1 = (CashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((CashFlow 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 void * SWIGSTDCALL CSharp_QuantLib_CashFlow_date(void * jarg1) {
  void * jresult ;
  CashFlow *arg1 = (CashFlow *) 0 ;
  ext::shared_ptr< CashFlow const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const CashFlow > *)jarg1;
  arg1 = (CashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((CashFlow 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(result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_CashFlow_hasOccurred__SWIG_0(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  CashFlow *arg1 = (CashFlow *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< CashFlow const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const CashFlow > *)jarg1;
  arg1 = (CashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)((CashFlow const *)arg1)->hasOccurred((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_CashFlow_hasOccurred__SWIG_1(void * jarg1) {
  unsigned int jresult ;
  CashFlow *arg1 = (CashFlow *) 0 ;
  ext::shared_ptr< CashFlow const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const CashFlow > *)jarg1;
  arg1 = (CashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((CashFlow const *)arg1)->hasOccurred();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_CashFlow(void * jarg1) {
  CashFlow *arg1 = (CashFlow *) 0 ;
  ext::shared_ptr< CashFlow > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CashFlow > *)jarg1;
  arg1 = (CashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_Clear(void * jarg1) {
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  
  arg1 = (std::vector< ext::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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  ext::shared_ptr< CashFlow > *arg2 = 0 ;
  ext::shared_ptr< CashFlow > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CashFlow > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (std::vector< ext::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< ext::shared_ptr< CashFlow > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< CashFlow > > *)new std::vector< ext::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< ext::shared_ptr< CashFlow > > *arg1 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CashFlow > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< ext::shared_ptr< CashFlow > > *)new std::vector< ext::shared_ptr< CashFlow > >((std::vector< ext::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< ext::shared_ptr< CashFlow > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CashFlow > > *)new_std_vector_Sl_ext_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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< CashFlow > result;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_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 = result ? new ext::shared_ptr< CashFlow >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Leg_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CashFlow > >::value_type *) &std_vector_Sl_ext_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 = *result ? new std::vector< ext::shared_ptr< CashFlow > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Leg_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< CashFlow > *arg3 = 0 ;
  ext::shared_ptr< CashFlow > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< CashFlow > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__setitem(arg1,arg2,(ext::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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CashFlow > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__AddRange(arg1,(std::vector< ext::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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< CashFlow > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CashFlow > > *)std_vector_Sl_ext_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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< CashFlow > *arg3 = 0 ;
  ext::shared_ptr< CashFlow > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< CashFlow > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__Insert(arg1,arg2,(ext::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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< CashFlow > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CashFlow > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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 ;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< CashFlow > tempnull1 ;
  std::vector< ext::shared_ptr< CashFlow > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CashFlow > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CashFlow > > *)std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__Repeat((ext::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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< CashFlow > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CashFlow > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  ext::shared_ptr< CashFlow > *arg2 = 0 ;
  ext::shared_ptr< CashFlow > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CashFlow > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__Contains(arg1,(ext::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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  ext::shared_ptr< CashFlow > *arg2 = 0 ;
  ext::shared_ptr< CashFlow > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CashFlow > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__IndexOf(arg1,(ext::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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  ext::shared_ptr< CashFlow > *arg2 = 0 ;
  ext::shared_ptr< CashFlow > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CashFlow > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__LastIndexOf(arg1,(ext::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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  ext::shared_ptr< CashFlow > *arg2 = 0 ;
  ext::shared_ptr< CashFlow > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CashFlow > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__Remove(arg1,(ext::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< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  
  arg1 = (std::vector< ext::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_LegVector_Clear(void * jarg1) {
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  
  arg1 = (std::vector< Leg > *)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_LegVector_Add(void * jarg1, void * jarg2) {
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  Leg *arg2 = 0 ;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (Leg *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((Leg 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_LegVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow > > >::size_type result;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  {
    try {
      result = ((std::vector< Leg > 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_LegVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow > > >::size_type result;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  {
    try {
      result = ((std::vector< Leg > 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_LegVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow > > >::size_type arg2 ;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (std::vector< std::vector< ext::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_LegVector__SWIG_0() {
  void * jresult ;
  std::vector< Leg > *result = 0 ;
  
  {
    try {
      result = (std::vector< Leg > *)new std::vector< Leg >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LegVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< Leg > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< Leg > *)new_std_vector_Sl_Leg_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_LegVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  int arg2 ;
  Leg result;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_Leg_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 Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LegVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  int arg2 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow > > >::value_type *result = 0 ;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::vector< ext::shared_ptr< CashFlow > > >::value_type *) &std_vector_Sl_Leg_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_LegVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  int arg2 ;
  Leg *arg3 = 0 ;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (Leg *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Leg_Sg__setitem(arg1,arg2,(std::vector< ext::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_LegVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< Leg > *arg2 = 0 ;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (std::vector< Leg > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Leg > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_Leg_Sg__AddRange(arg1,(std::vector< std::vector< ext::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_LegVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< Leg > *result = 0 ;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< Leg > *)std_vector_Sl_Leg_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_LegVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  int arg2 ;
  Leg *arg3 = 0 ;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (Leg *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Leg_Sg__Insert(arg1,arg2,(std::vector< ext::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_LegVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  int arg2 ;
  std::vector< Leg > *arg3 = 0 ;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< Leg > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Leg > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Leg_Sg__InsertRange(arg1,arg2,(std::vector< std::vector< ext::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_LegVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_Leg_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_LegVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_Leg_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_LegVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  Leg *arg1 = 0 ;
  int arg2 ;
  std::vector< Leg > *result = 0 ;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< Leg > *)std_vector_Sl_Leg_Sg__Repeat((std::vector< ext::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_LegVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  {
    try {
      std_vector_Sl_Leg_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_LegVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_Leg_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_LegVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  int arg2 ;
  std::vector< Leg > *arg3 = 0 ;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< Leg > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Leg > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_Leg_Sg__SetRange(arg1,arg2,(std::vector< std::vector< ext::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_LegVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  Leg *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (Leg *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_Leg_Sg__Contains(arg1,(std::vector< ext::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_LegVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  Leg *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (Leg *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_Leg_Sg__IndexOf(arg1,(std::vector< ext::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_LegVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  Leg *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (Leg *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)std_vector_Sl_Leg_Sg__LastIndexOf(arg1,(std::vector< ext::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_LegVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  Leg *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  arg2 = (Leg *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)std_vector_Sl_Leg_Sg__Remove(arg1,(std::vector< ext::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_LegVector(void * jarg1) {
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  
  arg1 = (std::vector< Leg > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  SimpleCashFlow *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SimpleCashFlow *)new SimpleCashFlow(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 ? new ext::shared_ptr<  SimpleCashFlow >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SimpleCashFlow(void * jarg1) {
  SimpleCashFlow *arg1 = (SimpleCashFlow *) 0 ;
  ext::shared_ptr< SimpleCashFlow > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SimpleCashFlow > *)jarg1;
  arg1 = (SimpleCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Redemption *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Redemption *)new Redemption(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 ? new ext::shared_ptr<  Redemption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Redemption(void * jarg1) {
  Redemption *arg1 = (Redemption *) 0 ;
  ext::shared_ptr< Redemption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Redemption > *)jarg1;
  arg1 = (Redemption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  AmortizingPayment *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingPayment *)new AmortizingPayment(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 ? new ext::shared_ptr<  AmortizingPayment >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AmortizingPayment(void * jarg1) {
  AmortizingPayment *arg1 = (AmortizingPayment *) 0 ;
  ext::shared_ptr< AmortizingPayment > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AmortizingPayment > *)jarg1;
  arg1 = (AmortizingPayment *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IndexedCashFlow__SWIG_0(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< Index > *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  bool arg6 ;
  ext::shared_ptr< Index > tempnull2 ;
  IndexedCashFlow *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Index > *)jarg2 : &tempnull2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (IndexedCashFlow *)new IndexedCashFlow(arg1,(ext::shared_ptr< Index > 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 ? new ext::shared_ptr<  IndexedCashFlow >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IndexedCashFlow__SWIG_1(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< Index > *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< Index > tempnull2 ;
  IndexedCashFlow *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Index > *)jarg2 : &tempnull2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (IndexedCashFlow *)new IndexedCashFlow(arg1,(ext::shared_ptr< Index > 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 ? new ext::shared_ptr<  IndexedCashFlow >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IndexedCashFlow_notional(void * jarg1) {
  double jresult ;
  IndexedCashFlow *arg1 = (IndexedCashFlow *) 0 ;
  ext::shared_ptr< IndexedCashFlow const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const IndexedCashFlow > *)jarg1;
  arg1 = (IndexedCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((IndexedCashFlow const *)arg1)->notional();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IndexedCashFlow_baseDate(void * jarg1) {
  void * jresult ;
  IndexedCashFlow *arg1 = (IndexedCashFlow *) 0 ;
  ext::shared_ptr< IndexedCashFlow const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const IndexedCashFlow > *)jarg1;
  arg1 = (IndexedCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((IndexedCashFlow const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IndexedCashFlow_fixingDate(void * jarg1) {
  void * jresult ;
  IndexedCashFlow *arg1 = (IndexedCashFlow *) 0 ;
  ext::shared_ptr< IndexedCashFlow const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const IndexedCashFlow > *)jarg1;
  arg1 = (IndexedCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((IndexedCashFlow const *)arg1)->fixingDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IndexedCashFlow_baseFixing(void * jarg1) {
  double jresult ;
  IndexedCashFlow *arg1 = (IndexedCashFlow *) 0 ;
  ext::shared_ptr< IndexedCashFlow const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const IndexedCashFlow > *)jarg1;
  arg1 = (IndexedCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((IndexedCashFlow const *)arg1)->baseFixing();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_IndexedCashFlow_indexFixing(void * jarg1) {
  double jresult ;
  IndexedCashFlow *arg1 = (IndexedCashFlow *) 0 ;
  ext::shared_ptr< IndexedCashFlow const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const IndexedCashFlow > *)jarg1;
  arg1 = (IndexedCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((IndexedCashFlow const *)arg1)->indexFixing();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IndexedCashFlow_index(void * jarg1) {
  void * jresult ;
  IndexedCashFlow *arg1 = (IndexedCashFlow *) 0 ;
  ext::shared_ptr< IndexedCashFlow const > *smartarg1 = 0 ;
  ext::shared_ptr< Index > result;
  
  
  smartarg1 = (ext::shared_ptr< const IndexedCashFlow > *)jarg1;
  arg1 = (IndexedCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((IndexedCashFlow const *)arg1)->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 = result ? new ext::shared_ptr< Index >(result) : 0; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_IndexedCashFlow_growthOnly(void * jarg1) {
  unsigned int jresult ;
  IndexedCashFlow *arg1 = (IndexedCashFlow *) 0 ;
  ext::shared_ptr< IndexedCashFlow const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const IndexedCashFlow > *)jarg1;
  arg1 = (IndexedCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((IndexedCashFlow const *)arg1)->growthOnly();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_IndexedCashFlow(void * jarg1) {
  IndexedCashFlow *arg1 = (IndexedCashFlow *) 0 ;
  ext::shared_ptr< IndexedCashFlow > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  IndexedCashFlow > *)jarg1;
  arg1 = (IndexedCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_indexed_cashflow(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  ext::shared_ptr< CashFlow > tempnull1 ;
  ext::shared_ptr< IndexedCashFlow > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< CashFlow > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_indexed_cashflow((ext::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 = result ? new ext::shared_ptr< IndexedCashFlow >(result) : 0; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Coupon_nominal(void * jarg1) {
  double jresult ;
  Coupon *arg1 = (Coupon *) 0 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Coupon > *)jarg1;
  arg1 = (Coupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((Coupon const *)arg1)->nominal();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Coupon *arg1 = (Coupon *) 0 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const Coupon > *)jarg1;
  arg1 = (Coupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Coupon const *)arg1)->accrualStartDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Coupon_accrualEndDate(void * jarg1) {
  void * jresult ;
  Coupon *arg1 = (Coupon *) 0 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const Coupon > *)jarg1;
  arg1 = (Coupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Coupon const *)arg1)->accrualEndDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Coupon_referencePeriodStart(void * jarg1) {
  void * jresult ;
  Coupon *arg1 = (Coupon *) 0 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const Coupon > *)jarg1;
  arg1 = (Coupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Coupon const *)arg1)->referencePeriodStart();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Coupon_referencePeriodEnd(void * jarg1) {
  void * jresult ;
  Coupon *arg1 = (Coupon *) 0 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const Coupon > *)jarg1;
  arg1 = (Coupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Coupon const *)arg1)->referencePeriodEnd();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Coupon_exCouponDate(void * jarg1) {
  void * jresult ;
  Coupon *arg1 = (Coupon *) 0 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const Coupon > *)jarg1;
  arg1 = (Coupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Coupon const *)arg1)->exCouponDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Coupon_rate(void * jarg1) {
  double jresult ;
  Coupon *arg1 = (Coupon *) 0 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Coupon > *)jarg1;
  arg1 = (Coupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((Coupon 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 double SWIGSTDCALL CSharp_QuantLib_Coupon_accrualPeriod(void * jarg1) {
  double jresult ;
  Coupon *arg1 = (Coupon *) 0 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  Time result;
  
  
  smartarg1 = (ext::shared_ptr< const Coupon > *)jarg1;
  arg1 = (Coupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Time)((Coupon const *)arg1)->accrualPeriod();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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 ;
  Coupon *arg1 = (Coupon *) 0 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  BigInteger result;
  
  
  smartarg1 = (ext::shared_ptr< const Coupon > *)jarg1;
  arg1 = (Coupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (BigInteger)((Coupon const *)arg1)->accrualDays();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Coupon *arg1 = (Coupon *) 0 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  SwigValueWrapper< DayCounter > result;
  
  
  smartarg1 = (ext::shared_ptr< const Coupon > *)jarg1;
  arg1 = (Coupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Coupon 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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Coupon_accruedAmount(void * jarg1, void * jarg2) {
  double jresult ;
  Coupon *arg1 = (Coupon *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Coupon > *)jarg1;
  arg1 = (Coupon *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Coupon const *)arg1)->accruedAmount((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) {
  Coupon *arg1 = (Coupon *) 0 ;
  ext::shared_ptr< Coupon > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Coupon > *)jarg1;
  arg1 = (Coupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  ext::shared_ptr< CashFlow > tempnull1 ;
  ext::shared_ptr< Coupon > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< CashFlow > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_coupon((ext::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 = result ? new ext::shared_ptr< Coupon >(result) : 0; 
  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 ;
  FixedRateCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateCoupon *)new FixedRateCoupon((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 = result ? new ext::shared_ptr<  FixedRateCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateCoupon *)new FixedRateCoupon((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 = result ? new ext::shared_ptr<  FixedRateCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateCoupon *)new FixedRateCoupon((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 = result ? new ext::shared_ptr<  FixedRateCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateCoupon *)new FixedRateCoupon((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 = result ? new ext::shared_ptr<  FixedRateCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateCoupon_interestRate(void * jarg1) {
  void * jresult ;
  FixedRateCoupon *arg1 = (FixedRateCoupon *) 0 ;
  ext::shared_ptr< FixedRateCoupon const > *smartarg1 = 0 ;
  InterestRate result;
  
  
  smartarg1 = (ext::shared_ptr< const FixedRateCoupon > *)jarg1;
  arg1 = (FixedRateCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((FixedRateCoupon const *)arg1)->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 = new InterestRate(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FixedRateCoupon(void * jarg1) {
  FixedRateCoupon *arg1 = (FixedRateCoupon *) 0 ;
  ext::shared_ptr< FixedRateCoupon > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FixedRateCoupon > *)jarg1;
  arg1 = (FixedRateCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  ext::shared_ptr< CashFlow > tempnull1 ;
  ext::shared_ptr< FixedRateCoupon > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< CashFlow > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_fixed_rate_coupon((ext::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 = result ? new ext::shared_ptr< FixedRateCoupon >(result) : 0; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FloatingRateCouponPricer_swapletPrice(void * jarg1) {
  double jresult ;
  FloatingRateCouponPricer *arg1 = (FloatingRateCouponPricer *) 0 ;
  ext::shared_ptr< FloatingRateCouponPricer const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingRateCouponPricer > *)jarg1;
  arg1 = (FloatingRateCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((FloatingRateCouponPricer const *)arg1)->swapletPrice();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FloatingRateCouponPricer_swapletRate(void * jarg1) {
  double jresult ;
  FloatingRateCouponPricer *arg1 = (FloatingRateCouponPricer *) 0 ;
  ext::shared_ptr< FloatingRateCouponPricer const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingRateCouponPricer > *)jarg1;
  arg1 = (FloatingRateCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((FloatingRateCouponPricer const *)arg1)->swapletRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FloatingRateCouponPricer_capletPrice(void * jarg1, double jarg2) {
  double jresult ;
  FloatingRateCouponPricer *arg1 = (FloatingRateCouponPricer *) 0 ;
  Rate arg2 ;
  ext::shared_ptr< FloatingRateCouponPricer const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingRateCouponPricer > *)jarg1;
  arg1 = (FloatingRateCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  {
    try {
      result = (Real)((FloatingRateCouponPricer const *)arg1)->capletPrice(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FloatingRateCouponPricer_capletRate(void * jarg1, double jarg2) {
  double jresult ;
  FloatingRateCouponPricer *arg1 = (FloatingRateCouponPricer *) 0 ;
  Rate arg2 ;
  ext::shared_ptr< FloatingRateCouponPricer const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingRateCouponPricer > *)jarg1;
  arg1 = (FloatingRateCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  {
    try {
      result = (Rate)((FloatingRateCouponPricer const *)arg1)->capletRate(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FloatingRateCouponPricer_floorletPrice(void * jarg1, double jarg2) {
  double jresult ;
  FloatingRateCouponPricer *arg1 = (FloatingRateCouponPricer *) 0 ;
  Rate arg2 ;
  ext::shared_ptr< FloatingRateCouponPricer const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingRateCouponPricer > *)jarg1;
  arg1 = (FloatingRateCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  {
    try {
      result = (Real)((FloatingRateCouponPricer const *)arg1)->floorletPrice(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FloatingRateCouponPricer_floorletRate(void * jarg1, double jarg2) {
  double jresult ;
  FloatingRateCouponPricer *arg1 = (FloatingRateCouponPricer *) 0 ;
  Rate arg2 ;
  ext::shared_ptr< FloatingRateCouponPricer const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingRateCouponPricer > *)jarg1;
  arg1 = (FloatingRateCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  {
    try {
      result = (Rate)((FloatingRateCouponPricer const *)arg1)->floorletRate(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_FloatingRateCouponPricer(void * jarg1) {
  FloatingRateCouponPricer *arg1 = (FloatingRateCouponPricer *) 0 ;
  ext::shared_ptr< FloatingRateCouponPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FloatingRateCouponPricer > *)jarg1;
  arg1 = (FloatingRateCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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__SWIG_0(void * jarg1, void * jarg2) {
  Leg *arg1 = 0 ;
  ext::shared_ptr< FloatingRateCouponPricer > *arg2 = 0 ;
  ext::shared_ptr< FloatingRateCouponPricer > tempnull2 ;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return ;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< FloatingRateCouponPricer > *)jarg2 : &tempnull2; 
  {
    try {
      setCouponPricer((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(ext::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 ;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingRateCoupon > *)jarg1;
  arg1 = (FloatingRateCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((FloatingRateCoupon const *)arg1)->fixingDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_FloatingRateCoupon_fixingDays(void * jarg1) {
  int jresult ;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  Integer result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingRateCoupon > *)jarg1;
  arg1 = (FloatingRateCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Integer)((FloatingRateCoupon const *)arg1)->fixingDays();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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 ;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingRateCoupon > *)jarg1;
  arg1 = (FloatingRateCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((FloatingRateCoupon const *)arg1)->isInArrears();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingRateCoupon > *)jarg1;
  arg1 = (FloatingRateCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((FloatingRateCoupon const *)arg1)->gearing();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingRateCoupon > *)jarg1;
  arg1 = (FloatingRateCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((FloatingRateCoupon const *)arg1)->spread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingRateCoupon > *)jarg1;
  arg1 = (FloatingRateCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((FloatingRateCoupon const *)arg1)->indexFixing();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingRateCoupon > *)jarg1;
  arg1 = (FloatingRateCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((FloatingRateCoupon const *)arg1)->adjustedFixing();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingRateCoupon > *)jarg1;
  arg1 = (FloatingRateCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((FloatingRateCoupon const *)arg1)->convexityAdjustment();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingRateCoupon > *)jarg1;
  arg1 = (FloatingRateCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((FloatingRateCoupon const *)arg1)->price((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 ;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  ext::shared_ptr< InterestRateIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingRateCoupon > *)jarg1;
  arg1 = (FloatingRateCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((FloatingRateCoupon const *)arg1)->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 = result ? new ext::shared_ptr< InterestRateIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FloatingRateCoupon_setPricer(void * jarg1, void * jarg2) {
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  ext::shared_ptr< FloatingRateCouponPricer > *arg2 = 0 ;
  ext::shared_ptr< FloatingRateCoupon > *smartarg1 = 0 ;
  ext::shared_ptr< FloatingRateCouponPricer > tempnull2 ;
  
  
  smartarg1 = (ext::shared_ptr<  FloatingRateCoupon > *)jarg1;
  arg1 = (FloatingRateCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (ext::shared_ptr< FloatingRateCouponPricer > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->setPricer((ext::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) {
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  ext::shared_ptr< FloatingRateCoupon > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FloatingRateCoupon > *)jarg1;
  arg1 = (FloatingRateCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  ext::shared_ptr< CashFlow > tempnull1 ;
  ext::shared_ptr< FloatingRateCoupon > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< CashFlow > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_floating_rate_coupon((ext::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 = result ? new ext::shared_ptr< FloatingRateCoupon >(result) : 0; 
  return jresult;
}


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


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedCoupon__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, double jarg7, void * jarg8, void * jarg9, void * jarg10, unsigned int jarg11, int jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Real arg6 ;
  Spread arg7 ;
  Date *arg8 = 0 ;
  Date *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  bool arg11 ;
  RateAveraging::Type arg12 ;
  ext::shared_ptr< OvernightIndex > tempnull5 ;
  OvernightIndexedCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< OvernightIndex > *)jarg5 : &tempnull5; 
  arg6 = (Real)jarg6; 
  arg7 = (Spread)jarg7; 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = (RateAveraging::Type)jarg12; 
  {
    try {
      result = (OvernightIndexedCoupon *)new OvernightIndexedCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6,arg7,(Date const &)*arg8,(Date const &)*arg9,(DayCounter 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 = result ? new ext::shared_ptr<  OvernightIndexedCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedCoupon__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, double jarg7, void * jarg8, void * jarg9, void * jarg10, unsigned int jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Real arg6 ;
  Spread arg7 ;
  Date *arg8 = 0 ;
  Date *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< OvernightIndex > tempnull5 ;
  OvernightIndexedCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< OvernightIndex > *)jarg5 : &tempnull5; 
  arg6 = (Real)jarg6; 
  arg7 = (Spread)jarg7; 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (OvernightIndexedCoupon *)new OvernightIndexedCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6,arg7,(Date const &)*arg8,(Date 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 = result ? new ext::shared_ptr<  OvernightIndexedCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedCoupon__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, double jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Real arg6 ;
  Spread arg7 ;
  Date *arg8 = 0 ;
  Date *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull5 ;
  OvernightIndexedCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< OvernightIndex > *)jarg5 : &tempnull5; 
  arg6 = (Real)jarg6; 
  arg7 = (Spread)jarg7; 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (OvernightIndexedCoupon *)new OvernightIndexedCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6,arg7,(Date const &)*arg8,(Date 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 = result ? new ext::shared_ptr<  OvernightIndexedCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedCoupon__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, double jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Real arg6 ;
  Spread arg7 ;
  Date *arg8 = 0 ;
  Date *arg9 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull5 ;
  OvernightIndexedCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< OvernightIndex > *)jarg5 : &tempnull5; 
  arg6 = (Real)jarg6; 
  arg7 = (Spread)jarg7; 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (OvernightIndexedCoupon *)new OvernightIndexedCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(ext::shared_ptr< OvernightIndex > const &)*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 ? new ext::shared_ptr<  OvernightIndexedCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedCoupon__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, double jarg7, void * jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Real arg6 ;
  Spread arg7 ;
  Date *arg8 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull5 ;
  OvernightIndexedCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< OvernightIndex > *)jarg5 : &tempnull5; 
  arg6 = (Real)jarg6; 
  arg7 = (Spread)jarg7; 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (OvernightIndexedCoupon *)new OvernightIndexedCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(ext::shared_ptr< OvernightIndex > const &)*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 ? new ext::shared_ptr<  OvernightIndexedCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedCoupon__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6, double jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Real arg6 ;
  Spread arg7 ;
  ext::shared_ptr< OvernightIndex > tempnull5 ;
  OvernightIndexedCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< OvernightIndex > *)jarg5 : &tempnull5; 
  arg6 = (Real)jarg6; 
  arg7 = (Spread)jarg7; 
  {
    try {
      result = (OvernightIndexedCoupon *)new OvernightIndexedCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OvernightIndexedCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedCoupon__SWIG_6(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, double jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Real arg6 ;
  ext::shared_ptr< OvernightIndex > tempnull5 ;
  OvernightIndexedCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< OvernightIndex > *)jarg5 : &tempnull5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (OvernightIndexedCoupon *)new OvernightIndexedCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(ext::shared_ptr< OvernightIndex > 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 ? new ext::shared_ptr<  OvernightIndexedCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedCoupon__SWIG_7(void * jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull5 ;
  OvernightIndexedCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< OvernightIndex > *)jarg5 : &tempnull5; 
  {
    try {
      result = (OvernightIndexedCoupon *)new OvernightIndexedCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(ext::shared_ptr< OvernightIndex > 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 ? new ext::shared_ptr<  OvernightIndexedCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightIndexedCoupon_fixingDates(void * jarg1) {
  void * jresult ;
  OvernightIndexedCoupon *arg1 = (OvernightIndexedCoupon *) 0 ;
  ext::shared_ptr< OvernightIndexedCoupon const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const OvernightIndexedCoupon > *)jarg1;
  arg1 = (OvernightIndexedCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((OvernightIndexedCoupon const *)arg1)->fixingDates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightIndexedCoupon_dt(void * jarg1) {
  void * jresult ;
  OvernightIndexedCoupon *arg1 = (OvernightIndexedCoupon *) 0 ;
  ext::shared_ptr< OvernightIndexedCoupon const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const OvernightIndexedCoupon > *)jarg1;
  arg1 = (OvernightIndexedCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((OvernightIndexedCoupon const *)arg1)->dt();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightIndexedCoupon_indexFixings(void * jarg1) {
  void * jresult ;
  OvernightIndexedCoupon *arg1 = (OvernightIndexedCoupon *) 0 ;
  ext::shared_ptr< OvernightIndexedCoupon const > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const OvernightIndexedCoupon > *)jarg1;
  arg1 = (OvernightIndexedCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Rate > *) &((OvernightIndexedCoupon const *)arg1)->indexFixings();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightIndexedCoupon_valueDates(void * jarg1) {
  void * jresult ;
  OvernightIndexedCoupon *arg1 = (OvernightIndexedCoupon *) 0 ;
  ext::shared_ptr< OvernightIndexedCoupon const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const OvernightIndexedCoupon > *)jarg1;
  arg1 = (OvernightIndexedCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((OvernightIndexedCoupon const *)arg1)->valueDates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_OvernightIndexedCoupon(void * jarg1) {
  OvernightIndexedCoupon *arg1 = (OvernightIndexedCoupon *) 0 ;
  ext::shared_ptr< OvernightIndexedCoupon > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedCoupon > *)jarg1;
  arg1 = (OvernightIndexedCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_overnight_indexed_coupon(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  ext::shared_ptr< CashFlow > tempnull1 ;
  ext::shared_ptr< OvernightIndexedCoupon > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< CashFlow > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_overnight_indexed_coupon((ext::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 = result ? new ext::shared_ptr< OvernightIndexedCoupon >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCoupon__SWIG_0(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< FloatingRateCoupon > *arg1 = 0 ;
  Rate arg2 ;
  Rate arg3 ;
  ext::shared_ptr< FloatingRateCoupon > tempnull1 ;
  CappedFlooredCoupon *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FloatingRateCoupon > *)jarg1 : &tempnull1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (CappedFlooredCoupon *)new CappedFlooredCoupon((ext::shared_ptr< FloatingRateCoupon > 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 ? new ext::shared_ptr<  CappedFlooredCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCoupon__SWIG_1(void * jarg1, double jarg2) {
  void * jresult ;
  ext::shared_ptr< FloatingRateCoupon > *arg1 = 0 ;
  Rate arg2 ;
  ext::shared_ptr< FloatingRateCoupon > tempnull1 ;
  CappedFlooredCoupon *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FloatingRateCoupon > *)jarg1 : &tempnull1; 
  arg2 = (Rate)jarg2; 
  {
    try {
      result = (CappedFlooredCoupon *)new CappedFlooredCoupon((ext::shared_ptr< FloatingRateCoupon > 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 ? new ext::shared_ptr<  CappedFlooredCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCoupon__SWIG_2(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< FloatingRateCoupon > *arg1 = 0 ;
  ext::shared_ptr< FloatingRateCoupon > tempnull1 ;
  CappedFlooredCoupon *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FloatingRateCoupon > *)jarg1 : &tempnull1; 
  {
    try {
      result = (CappedFlooredCoupon *)new CappedFlooredCoupon((ext::shared_ptr< FloatingRateCoupon > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  CappedFlooredCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CappedFlooredCoupon_cap(void * jarg1) {
  double jresult ;
  CappedFlooredCoupon *arg1 = (CappedFlooredCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredCoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CappedFlooredCoupon > *)jarg1;
  arg1 = (CappedFlooredCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CappedFlooredCoupon const *)arg1)->cap();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  CappedFlooredCoupon *arg1 = (CappedFlooredCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredCoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CappedFlooredCoupon > *)jarg1;
  arg1 = (CappedFlooredCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CappedFlooredCoupon const *)arg1)->floor();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  CappedFlooredCoupon *arg1 = (CappedFlooredCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredCoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CappedFlooredCoupon > *)jarg1;
  arg1 = (CappedFlooredCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CappedFlooredCoupon const *)arg1)->effectiveCap();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  CappedFlooredCoupon *arg1 = (CappedFlooredCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredCoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CappedFlooredCoupon > *)jarg1;
  arg1 = (CappedFlooredCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CappedFlooredCoupon const *)arg1)->effectiveFloor();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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 ;
  CappedFlooredCoupon *arg1 = (CappedFlooredCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredCoupon const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const CappedFlooredCoupon > *)jarg1;
  arg1 = (CappedFlooredCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((CappedFlooredCoupon const *)arg1)->isCapped();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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 ;
  CappedFlooredCoupon *arg1 = (CappedFlooredCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredCoupon const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const CappedFlooredCoupon > *)jarg1;
  arg1 = (CappedFlooredCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((CappedFlooredCoupon const *)arg1)->isFloored();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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) {
  CappedFlooredCoupon *arg1 = (CappedFlooredCoupon *) 0 ;
  ext::shared_ptr< FloatingRateCouponPricer > *arg2 = 0 ;
  ext::shared_ptr< CappedFlooredCoupon > *smartarg1 = 0 ;
  ext::shared_ptr< FloatingRateCouponPricer > tempnull2 ;
  
  
  smartarg1 = (ext::shared_ptr<  CappedFlooredCoupon > *)jarg1;
  arg1 = (CappedFlooredCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (ext::shared_ptr< FloatingRateCouponPricer > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->setPricer((ext::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) {
  CappedFlooredCoupon *arg1 = (CappedFlooredCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredCoupon > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CappedFlooredCoupon > *)jarg1;
  arg1 = (CappedFlooredCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, unsigned int jarg12, void * jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  Date *arg13 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  IborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (IborCoupon *)new IborCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,*arg6,arg7,arg8,(Date const &)*arg9,(Date const &)*arg10,(DayCounter const &)*arg11,arg12,(Date 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 = result ? new ext::shared_ptr<  IborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg11, unsigned int jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  IborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (IborCoupon *)new IborCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,*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 = result ? new ext::shared_ptr<  IborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg10, void * jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  IborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (IborCoupon *)new IborCoupon((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 = result ? new ext::shared_ptr<  IborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg9, void * jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  IborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (IborCoupon *)new IborCoupon((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 = result ? new ext::shared_ptr<  IborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, double jarg8, void * jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  IborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (IborCoupon *)new IborCoupon((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 = result ? new ext::shared_ptr<  IborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IborCoupon__SWIG_5(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 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  IborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  {
    try {
      result = (IborCoupon *)new IborCoupon((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 = result ? new ext::shared_ptr<  IborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IborCoupon__SWIG_6(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 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  IborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (IborCoupon *)new IborCoupon((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 = result ? new ext::shared_ptr<  IborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IborCoupon__SWIG_7(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 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  IborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  {
    try {
      result = (IborCoupon *)new IborCoupon((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 = result ? new ext::shared_ptr<  IborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IborCoupon_createAtParCoupons() {
  {
    try {
      IborCoupon_createAtParCoupons();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IborCoupon_createIndexedCoupons() {
  {
    try {
      IborCoupon_createIndexedCoupons();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_IborCoupon_usingAtParCoupons() {
  unsigned int jresult ;
  bool result;
  
  {
    try {
      result = (bool)IborCoupon_usingAtParCoupons();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_IborCoupon(void * jarg1) {
  IborCoupon *arg1 = (IborCoupon *) 0 ;
  ext::shared_ptr< IborCoupon > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  IborCoupon > *)jarg1;
  arg1 = (IborCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredIborCoupon__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, double jarg10, void * jarg11, void * jarg12, void * jarg13, unsigned int jarg14, void * jarg15) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  CappedFlooredIborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (DayCounter *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg14 = jarg14 ? true : false; 
  arg15 = (Date *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredIborCoupon *)new CappedFlooredIborCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11,(Date const &)*arg12,(DayCounter const &)*arg13,arg14,(Date 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 = result ? new ext::shared_ptr<  CappedFlooredIborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredIborCoupon__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, 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 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  CappedFlooredIborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (DayCounter *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (CappedFlooredIborCoupon *)new CappedFlooredIborCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,*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 = result ? new ext::shared_ptr<  CappedFlooredIborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredIborCoupon__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, 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 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  CappedFlooredIborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (DayCounter *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredIborCoupon *)new CappedFlooredIborCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,*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 = result ? new ext::shared_ptr<  CappedFlooredIborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredIborCoupon__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, 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 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  CappedFlooredIborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredIborCoupon *)new CappedFlooredIborCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,*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 = result ? new ext::shared_ptr<  CappedFlooredIborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredIborCoupon__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, 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 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  CappedFlooredIborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredIborCoupon *)new CappedFlooredIborCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,*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 = result ? new ext::shared_ptr<  CappedFlooredIborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredIborCoupon__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4, 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 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  CappedFlooredIborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  {
    try {
      result = (CappedFlooredIborCoupon *)new CappedFlooredIborCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date 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 ? new ext::shared_ptr<  CappedFlooredIborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredIborCoupon__SWIG_6(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, double jarg7, double jarg8, double jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  CappedFlooredIborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  {
    try {
      result = (CappedFlooredIborCoupon *)new CappedFlooredIborCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date 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 ? new ext::shared_ptr<  CappedFlooredIborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredIborCoupon__SWIG_7(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 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  CappedFlooredIborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  {
    try {
      result = (CappedFlooredIborCoupon *)new CappedFlooredIborCoupon((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 = result ? new ext::shared_ptr<  CappedFlooredIborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredIborCoupon__SWIG_8(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 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  CappedFlooredIborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (CappedFlooredIborCoupon *)new CappedFlooredIborCoupon((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 = result ? new ext::shared_ptr<  CappedFlooredIborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredIborCoupon__SWIG_9(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 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  CappedFlooredIborCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  {
    try {
      result = (CappedFlooredIborCoupon *)new CappedFlooredIborCoupon((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 = result ? new ext::shared_ptr<  CappedFlooredIborCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CappedFlooredIborCoupon(void * jarg1) {
  CappedFlooredIborCoupon *arg1 = (CappedFlooredIborCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredIborCoupon > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CappedFlooredIborCoupon > *)jarg1;
  arg1 = (CappedFlooredIborCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SubPeriodsCoupon__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Rate arg8 ;
  Rate arg9 ;
  Date *arg10 = 0 ;
  Date *arg11 = 0 ;
  DayCounter *arg12 = 0 ;
  Date *arg13 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  SubPeriodsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Rate)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (DayCounter *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SubPeriodsCoupon *)new SubPeriodsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,arg8,arg9,(Date const &)*arg10,(Date const &)*arg11,(DayCounter const &)*arg12,(Date 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 = result ? new ext::shared_ptr<  SubPeriodsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SubPeriodsCoupon__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, void * jarg10, void * jarg11, void * jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Rate arg8 ;
  Rate arg9 ;
  Date *arg10 = 0 ;
  Date *arg11 = 0 ;
  DayCounter *arg12 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  SubPeriodsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Rate)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (DayCounter *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SubPeriodsCoupon *)new SubPeriodsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,arg8,arg9,(Date const &)*arg10,(Date const &)*arg11,(DayCounter 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 = result ? new ext::shared_ptr<  SubPeriodsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SubPeriodsCoupon__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Rate arg8 ;
  Rate arg9 ;
  Date *arg10 = 0 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  SubPeriodsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Rate)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SubPeriodsCoupon *)new SubPeriodsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,arg8,arg9,(Date const &)*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 = result ? new ext::shared_ptr<  SubPeriodsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SubPeriodsCoupon__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, double jarg7, double jarg8, double jarg9, void * jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Rate arg8 ;
  Rate arg9 ;
  Date *arg10 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  SubPeriodsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Rate)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SubPeriodsCoupon *)new SubPeriodsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,arg8,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 = result ? new ext::shared_ptr<  SubPeriodsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SubPeriodsCoupon__SWIG_4(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 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Rate arg8 ;
  Rate arg9 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  SubPeriodsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Rate)jarg8; 
  arg9 = (Rate)jarg9; 
  {
    try {
      result = (SubPeriodsCoupon *)new SubPeriodsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SubPeriodsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SubPeriodsCoupon__SWIG_5(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 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  Rate arg8 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  SubPeriodsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Rate)jarg8; 
  {
    try {
      result = (SubPeriodsCoupon *)new SubPeriodsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  SubPeriodsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SubPeriodsCoupon__SWIG_6(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 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  SubPeriodsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (SubPeriodsCoupon *)new SubPeriodsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  SubPeriodsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SubPeriodsCoupon__SWIG_7(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 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  SubPeriodsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  {
    try {
      result = (SubPeriodsCoupon *)new SubPeriodsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  SubPeriodsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsCoupon_fixingDates(void * jarg1) {
  void * jresult ;
  SubPeriodsCoupon *arg1 = (SubPeriodsCoupon *) 0 ;
  ext::shared_ptr< SubPeriodsCoupon const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const SubPeriodsCoupon > *)jarg1;
  arg1 = (SubPeriodsCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((SubPeriodsCoupon const *)arg1)->fixingDates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsCoupon_dt(void * jarg1) {
  void * jresult ;
  SubPeriodsCoupon *arg1 = (SubPeriodsCoupon *) 0 ;
  ext::shared_ptr< SubPeriodsCoupon const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const SubPeriodsCoupon > *)jarg1;
  arg1 = (SubPeriodsCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((SubPeriodsCoupon const *)arg1)->dt();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsCoupon_valueDates(void * jarg1) {
  void * jresult ;
  SubPeriodsCoupon *arg1 = (SubPeriodsCoupon *) 0 ;
  ext::shared_ptr< SubPeriodsCoupon const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const SubPeriodsCoupon > *)jarg1;
  arg1 = (SubPeriodsCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((SubPeriodsCoupon const *)arg1)->valueDates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_SubPeriodsCoupon_rateSpread(void * jarg1) {
  double jresult ;
  SubPeriodsCoupon *arg1 = (SubPeriodsCoupon *) 0 ;
  ext::shared_ptr< SubPeriodsCoupon const > *smartarg1 = 0 ;
  Spread result;
  
  
  smartarg1 = (ext::shared_ptr< const SubPeriodsCoupon > *)jarg1;
  arg1 = (SubPeriodsCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Spread)((SubPeriodsCoupon const *)arg1)->rateSpread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_SubPeriodsCoupon(void * jarg1) {
  SubPeriodsCoupon *arg1 = (SubPeriodsCoupon *) 0 ;
  ext::shared_ptr< SubPeriodsCoupon > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SubPeriodsCoupon > *)jarg1;
  arg1 = (SubPeriodsCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_sub_periods_coupon(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  ext::shared_ptr< CashFlow > tempnull1 ;
  ext::shared_ptr< SubPeriodsCoupon > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< CashFlow > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_sub_periods_coupon((ext::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 = result ? new ext::shared_ptr< SubPeriodsCoupon >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborCouponPricer_capletVolatility(void * jarg1) {
  void * jresult ;
  IborCouponPricer *arg1 = (IborCouponPricer *) 0 ;
  ext::shared_ptr< IborCouponPricer const > *smartarg1 = 0 ;
  Handle< OptionletVolatilityStructure > result;
  
  
  smartarg1 = (ext::shared_ptr< const IborCouponPricer > *)jarg1;
  arg1 = (IborCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((IborCouponPricer const *)arg1)->capletVolatility();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_IborCouponPricer_setCapletVolatility__SWIG_0(void * jarg1, void * jarg2) {
  IborCouponPricer *arg1 = (IborCouponPricer *) 0 ;
  Handle< OptionletVolatilityStructure > *arg2 = 0 ;
  ext::shared_ptr< IborCouponPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  IborCouponPricer > *)jarg1;
  arg1 = (IborCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Handle< OptionletVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< OptionletVolatilityStructure > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->setCapletVolatility((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) {
  IborCouponPricer *arg1 = (IborCouponPricer *) 0 ;
  ext::shared_ptr< IborCouponPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  IborCouponPricer > *)jarg1;
  arg1 = (IborCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (arg1)->setCapletVolatility();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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) {
  IborCouponPricer *arg1 = (IborCouponPricer *) 0 ;
  ext::shared_ptr< IborCouponPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  IborCouponPricer > *)jarg1;
  arg1 = (IborCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, int jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = 0 ;
  BlackIborCouponPricer::TimingAdjustment arg2 ;
  Handle< Quote > arg3 ;
  SwigValueWrapper< ext::optional< bool > > arg4 ;
  Handle< Quote > const *argp3 ;
  ext::optional< bool > *argp4 ;
  BlackIborCouponPricer *result = 0 ;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< OptionletVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (BlackIborCouponPricer::TimingAdjustment)jarg2; 
  argp3 = (Handle< Quote > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote > const", 0);
    return 0;
  }
  arg3 = *argp3; 
  argp4 = (ext::optional< bool > *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg4 = *argp4; 
  {
    try {
      result = (BlackIborCouponPricer *)new BlackIborCouponPricer((Handle< OptionletVolatilityStructure > 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 ? new ext::shared_ptr<  BlackIborCouponPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackIborCouponPricer__SWIG_1(void * jarg1, int jarg2, void * jarg3) {
  void * jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = 0 ;
  BlackIborCouponPricer::TimingAdjustment arg2 ;
  Handle< Quote > arg3 ;
  Handle< Quote > const *argp3 ;
  BlackIborCouponPricer *result = 0 ;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< OptionletVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (BlackIborCouponPricer::TimingAdjustment)jarg2; 
  argp3 = (Handle< Quote > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote > const", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (BlackIborCouponPricer *)new BlackIborCouponPricer((Handle< OptionletVolatilityStructure > 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 ? new ext::shared_ptr<  BlackIborCouponPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackIborCouponPricer__SWIG_2(void * jarg1, int jarg2) {
  void * jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = 0 ;
  BlackIborCouponPricer::TimingAdjustment arg2 ;
  BlackIborCouponPricer *result = 0 ;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< OptionletVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (BlackIborCouponPricer::TimingAdjustment)jarg2; 
  {
    try {
      result = (BlackIborCouponPricer *)new BlackIborCouponPricer((Handle< OptionletVolatilityStructure > 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 ? new ext::shared_ptr<  BlackIborCouponPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackIborCouponPricer__SWIG_3(void * jarg1) {
  void * jresult ;
  Handle< OptionletVolatilityStructure > *arg1 = 0 ;
  BlackIborCouponPricer *result = 0 ;
  
  arg1 = (Handle< OptionletVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< OptionletVolatilityStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackIborCouponPricer *)new BlackIborCouponPricer((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 = result ? new ext::shared_ptr<  BlackIborCouponPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackIborCouponPricer(void * jarg1) {
  BlackIborCouponPricer *arg1 = (BlackIborCouponPricer *) 0 ;
  ext::shared_ptr< BlackIborCouponPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackIborCouponPricer > *)jarg1;
  arg1 = (BlackIborCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_SubPeriodsPricer(void * jarg1) {
  SubPeriodsPricer *arg1 = (SubPeriodsPricer *) 0 ;
  ext::shared_ptr< SubPeriodsPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SubPeriodsPricer > *)jarg1;
  arg1 = (SubPeriodsPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CompoundingRatePricer(void * jarg1) {
  CompoundingRatePricer *arg1 = (CompoundingRatePricer *) 0 ;
  ext::shared_ptr< CompoundingRatePricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CompoundingRatePricer > *)jarg1;
  arg1 = (CompoundingRatePricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AveragingRatePricer(void * jarg1) {
  AveragingRatePricer *arg1 = (AveragingRatePricer *) 0 ;
  ext::shared_ptr< AveragingRatePricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AveragingRatePricer > *)jarg1;
  arg1 = (AveragingRatePricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 * jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  Date *arg13 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsCoupon *)new CmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,arg7,arg8,(Date const &)*arg9,(Date const &)*arg10,(DayCounter const &)*arg11,arg12,(Date 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 = result ? new ext::shared_ptr<  CmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, unsigned int jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (CmsCoupon *)new CmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  CmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsCoupon *)new CmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  CmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsCoupon *)new CmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  CmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsCoupon *)new CmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  CmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, double jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  {
    try {
      result = (CmsCoupon *)new CmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > 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 ? new ext::shared_ptr<  CmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsCoupon__SWIG_6(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 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (CmsCoupon *)new CmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > 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 ? new ext::shared_ptr<  CmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsCoupon__SWIG_7(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 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  {
    try {
      result = (CmsCoupon *)new CmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > 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 ? new ext::shared_ptr<  CmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CmsCoupon(void * jarg1) {
  CmsCoupon *arg1 = (CmsCoupon *) 0 ;
  ext::shared_ptr< CmsCoupon > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CmsCoupon > *)jarg1;
  arg1 = (CmsCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsSpreadCoupon__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, double jarg7, double jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, void * jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  Date *arg13 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsSpreadCoupon *)new CmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > const &)*arg6,arg7,arg8,(Date const &)*arg9,(Date const &)*arg10,(DayCounter const &)*arg11,arg12,(Date 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 = result ? new ext::shared_ptr<  CmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsSpreadCoupon__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned 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 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (CmsSpreadCoupon *)new CmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > 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 = result ? new ext::shared_ptr<  CmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsSpreadCoupon__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned 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 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsSpreadCoupon *)new CmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > 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 = result ? new ext::shared_ptr<  CmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsSpreadCoupon__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned 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 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsSpreadCoupon *)new CmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > 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 = result ? new ext::shared_ptr<  CmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsSpreadCoupon__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, double jarg7, double jarg8, void * jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Date *arg9 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsSpreadCoupon *)new CmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > 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 = result ? new ext::shared_ptr<  CmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsSpreadCoupon__SWIG_5(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 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  {
    try {
      result = (CmsSpreadCoupon *)new CmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > 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 ? new ext::shared_ptr<  CmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsSpreadCoupon__SWIG_6(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 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (CmsSpreadCoupon *)new CmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > 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 ? new ext::shared_ptr<  CmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsSpreadCoupon__SWIG_7(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 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  {
    try {
      result = (CmsSpreadCoupon *)new CmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > 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 ? new ext::shared_ptr<  CmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CmsSpreadCoupon(void * jarg1) {
  CmsSpreadCoupon *arg1 = (CmsSpreadCoupon *) 0 ;
  ext::shared_ptr< CmsSpreadCoupon > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CmsSpreadCoupon > *)jarg1;
  arg1 = (CmsSpreadCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  CmsCouponPricer *arg1 = (CmsCouponPricer *) 0 ;
  ext::shared_ptr< CmsCouponPricer const > *smartarg1 = 0 ;
  Handle< SwaptionVolatilityStructure > result;
  
  
  smartarg1 = (ext::shared_ptr< const CmsCouponPricer > *)jarg1;
  arg1 = (CmsCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((CmsCouponPricer const *)arg1)->swaptionVolatility();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CmsCouponPricer_setSwaptionVolatility__SWIG_0(void * jarg1, void * jarg2) {
  CmsCouponPricer *arg1 = (CmsCouponPricer *) 0 ;
  Handle< SwaptionVolatilityStructure > *arg2 = 0 ;
  ext::shared_ptr< CmsCouponPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CmsCouponPricer > *)jarg1;
  arg1 = (CmsCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Handle< SwaptionVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->setSwaptionVolatility((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) {
  CmsCouponPricer *arg1 = (CmsCouponPricer *) 0 ;
  ext::shared_ptr< CmsCouponPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CmsCouponPricer > *)jarg1;
  arg1 = (CmsCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (arg1)->setSwaptionVolatility();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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) {
  CmsCouponPricer *arg1 = (CmsCouponPricer *) 0 ;
  ext::shared_ptr< CmsCouponPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CmsCouponPricer > *)jarg1;
  arg1 = (CmsCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CmsCouponPricerVector_Clear(void * jarg1) {
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)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_CmsCouponPricerVector_Add(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  ext::shared_ptr< CmsCouponPricer > *arg2 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CmsCouponPricer > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::shared_ptr< CmsCouponPricer > 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_CmsCouponPricerVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< CmsCouponPricer > > 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_CmsCouponPricerVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< CmsCouponPricer > > 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_CmsCouponPricerVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< CmsCouponPricer > >::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_CmsCouponPricerVector__SWIG_0() {
  void * jresult ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)new std::vector< ext::shared_ptr< CmsCouponPricer > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CmsCouponPricerVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)new_std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_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_CmsCouponPricerVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< CmsCouponPricer > result;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_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 = result ? new ext::shared_ptr< CmsCouponPricer >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsCouponPricerVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_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 = *result ? new std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CmsCouponPricerVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< CmsCouponPricer > *arg3 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< CmsCouponPricer > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__setitem(arg1,arg2,(ext::shared_ptr< CmsCouponPricer > 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_CmsCouponPricerVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CmsCouponPricer > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__AddRange(arg1,(std::vector< ext::shared_ptr< CmsCouponPricer > > 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_CmsCouponPricerVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_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_CmsCouponPricerVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< CmsCouponPricer > *arg3 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< CmsCouponPricer > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__Insert(arg1,arg2,(ext::shared_ptr< CmsCouponPricer > 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_CmsCouponPricerVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CmsCouponPricer > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::shared_ptr< CmsCouponPricer > > 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_CmsCouponPricerVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_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_CmsCouponPricerVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_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_CmsCouponPricerVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< CmsCouponPricer > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< CmsCouponPricer > tempnull1 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CmsCouponPricer > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__Repeat((ext::shared_ptr< CmsCouponPricer > 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_CmsCouponPricerVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_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_CmsCouponPricerVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_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_CmsCouponPricerVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CmsCouponPricer > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::shared_ptr< CmsCouponPricer > > 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_CmsCouponPricerVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  ext::shared_ptr< CmsCouponPricer > *arg2 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CmsCouponPricer > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__Contains(arg1,(ext::shared_ptr< CmsCouponPricer > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_CmsCouponPricerVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  ext::shared_ptr< CmsCouponPricer > *arg2 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CmsCouponPricer > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__IndexOf(arg1,(ext::shared_ptr< CmsCouponPricer > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_CmsCouponPricerVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  ext::shared_ptr< CmsCouponPricer > *arg2 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CmsCouponPricer > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__LastIndexOf(arg1,(ext::shared_ptr< CmsCouponPricer > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_CmsCouponPricerVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  ext::shared_ptr< CmsCouponPricer > *arg2 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CmsCouponPricer > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__Remove(arg1,(ext::shared_ptr< CmsCouponPricer > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_CmsCouponPricerVector(void * jarg1) {
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  AnalyticHaganPricer *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (GFunctionFactory::YieldCurveModel)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticHaganPricer *)new AnalyticHaganPricer((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 = result ? new ext::shared_ptr<  AnalyticHaganPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticHaganPricer(void * jarg1) {
  AnalyticHaganPricer *arg1 = (AnalyticHaganPricer *) 0 ;
  ext::shared_ptr< AnalyticHaganPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticHaganPricer > *)jarg1;
  arg1 = (AnalyticHaganPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  NumericHaganPricer *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (GFunctionFactory::YieldCurveModel)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (Rate)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (NumericHaganPricer *)new NumericHaganPricer((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 = result ? new ext::shared_ptr<  NumericHaganPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  NumericHaganPricer *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (GFunctionFactory::YieldCurveModel)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (Rate)jarg5; 
  {
    try {
      result = (NumericHaganPricer *)new NumericHaganPricer((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 = result ? new ext::shared_ptr<  NumericHaganPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  NumericHaganPricer *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (GFunctionFactory::YieldCurveModel)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (NumericHaganPricer *)new NumericHaganPricer((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 = result ? new ext::shared_ptr<  NumericHaganPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  NumericHaganPricer *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (GFunctionFactory::YieldCurveModel)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (NumericHaganPricer *)new NumericHaganPricer((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 = result ? new ext::shared_ptr<  NumericHaganPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NumericHaganPricer(void * jarg1) {
  NumericHaganPricer *arg1 = (NumericHaganPricer *) 0 ;
  ext::shared_ptr< NumericHaganPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  NumericHaganPricer > *)jarg1;
  arg1 = (NumericHaganPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 * jarg15) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (DayCounter *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg14 = jarg14 ? true : false; 
  arg15 = (Date *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11,(Date const &)*arg12,(DayCounter const &)*arg13,arg14,(Date 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 = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, unsigned int jarg14) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (DayCounter *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (DayCounter *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, double jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, double jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, double jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > 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 ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsCoupon__SWIG_8(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 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > 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 ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsCoupon__SWIG_9(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 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull6 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapIndex > *)jarg6 : &tempnull6; 
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > 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 ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CappedFlooredCmsCoupon(void * jarg1) {
  CappedFlooredCmsCoupon *arg1 = (CappedFlooredCmsCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredCmsCoupon > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CappedFlooredCmsCoupon > *)jarg1;
  arg1 = (CappedFlooredCmsCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsSpreadCoupon__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 * jarg15) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (DayCounter *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg14 = jarg14 ? true : false; 
  arg15 = (Date *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > const &)*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11,(Date const &)*arg12,(DayCounter const &)*arg13,arg14,(Date 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 = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsSpreadCoupon__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, unsigned int jarg14) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (DayCounter *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > 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 = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsSpreadCoupon__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 * jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (DayCounter *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > 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 = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsSpreadCoupon__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 * jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > 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 = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsSpreadCoupon__SWIG_4(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 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > 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 = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsSpreadCoupon__SWIG_5(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 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Rate)jarg10; 
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > 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 = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsSpreadCoupon__SWIG_6(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 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  arg9 = (Rate)jarg9; 
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > 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 = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsSpreadCoupon__SWIG_7(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 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  arg8 = (Spread)jarg8; 
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > 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 ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsSpreadCoupon__SWIG_8(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 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > 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 ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredCmsSpreadCoupon__SWIG_9(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 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull6 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg6 : &tempnull6; 
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > 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 ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CappedFlooredCmsSpreadCoupon(void * jarg1) {
  CappedFlooredCmsSpreadCoupon *arg1 = (CappedFlooredCmsSpreadCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredCmsSpreadCoupon > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CappedFlooredCmsSpreadCoupon > *)jarg1;
  arg1 = (CappedFlooredCmsSpreadCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  LinearTsrPricer *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (LinearTsrPricer::Settings *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LinearTsrPricer::Settings const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (LinearTsrPricer *)new LinearTsrPricer((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 = result ? new ext::shared_ptr<  LinearTsrPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  LinearTsrPricer *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (LinearTsrPricer *)new LinearTsrPricer((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 = result ? new ext::shared_ptr<  LinearTsrPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  LinearTsrPricer *result = 0 ;
  
  arg1 = (Handle< SwaptionVolatilityStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (LinearTsrPricer *)new LinearTsrPricer((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 = result ? new ext::shared_ptr<  LinearTsrPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LinearTsrPricer(void * jarg1) {
  LinearTsrPricer *arg1 = (LinearTsrPricer *) 0 ;
  ext::shared_ptr< LinearTsrPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  LinearTsrPricer > *)jarg1;
  arg1 = (LinearTsrPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LinearTsrPricerSettings_withRateBound__SWIG_0(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  Real arg2 ;
  Real arg3 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  arg1 = (LinearTsrPricer::Settings *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withRateBound(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_LinearTsrPricerSettings_withRateBound__SWIG_1(void * jarg1, double jarg2) {
  void * jresult ;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  Real arg2 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  arg1 = (LinearTsrPricer::Settings *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withRateBound(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LinearTsrPricerSettings_withRateBound__SWIG_2(void * jarg1) {
  void * jresult ;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  arg1 = (LinearTsrPricer::Settings *)jarg1; 
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withRateBound();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LinearTsrPricerSettings_withVegaRatio__SWIG_0(void * jarg1, double jarg2) {
  void * jresult ;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  Real arg2 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  arg1 = (LinearTsrPricer::Settings *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withVegaRatio(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LinearTsrPricerSettings_withVegaRatio__SWIG_1(void * jarg1) {
  void * jresult ;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  arg1 = (LinearTsrPricer::Settings *)jarg1; 
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withVegaRatio();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LinearTsrPricerSettings_withVegaRatio__SWIG_2(void * jarg1, double jarg2, double jarg3, double jarg4) {
  void * jresult ;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  arg1 = (LinearTsrPricer::Settings *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withVegaRatio(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_LinearTsrPricerSettings_withPriceThreshold__SWIG_0(void * jarg1, double jarg2) {
  void * jresult ;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  Real arg2 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  arg1 = (LinearTsrPricer::Settings *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withPriceThreshold(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LinearTsrPricerSettings_withPriceThreshold__SWIG_1(void * jarg1) {
  void * jresult ;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  arg1 = (LinearTsrPricer::Settings *)jarg1; 
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withPriceThreshold();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LinearTsrPricerSettings_withPriceThreshold__SWIG_2(void * jarg1, double jarg2, double jarg3, double jarg4) {
  void * jresult ;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  arg1 = (LinearTsrPricer::Settings *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withPriceThreshold(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_LinearTsrPricerSettings_withBSStdDevs__SWIG_0(void * jarg1, double jarg2) {
  void * jresult ;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  Real arg2 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  arg1 = (LinearTsrPricer::Settings *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withBSStdDevs(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LinearTsrPricerSettings_withBSStdDevs__SWIG_1(void * jarg1) {
  void * jresult ;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  arg1 = (LinearTsrPricer::Settings *)jarg1; 
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withBSStdDevs();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LinearTsrPricerSettings_withBSStdDevs__SWIG_2(void * jarg1, double jarg2, double jarg3, double jarg4) {
  void * jresult ;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  arg1 = (LinearTsrPricer::Settings *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withBSStdDevs(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_LinearTsrPricerSettings(void * jarg1) {
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  
  arg1 = (LinearTsrPricer::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 void * SWIGSTDCALL CSharp_QuantLib_CmsSpreadCouponPricer_correlation(void * jarg1) {
  void * jresult ;
  CmsSpreadCouponPricer *arg1 = (CmsSpreadCouponPricer *) 0 ;
  ext::shared_ptr< CmsSpreadCouponPricer const > *smartarg1 = 0 ;
  Handle< Quote > result;
  
  
  smartarg1 = (ext::shared_ptr< const CmsSpreadCouponPricer > *)jarg1;
  arg1 = (CmsSpreadCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((CmsSpreadCouponPricer 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 Handle< Quote >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CmsSpreadCouponPricer_setCorrelation__SWIG_0(void * jarg1, void * jarg2) {
  CmsSpreadCouponPricer *arg1 = (CmsSpreadCouponPricer *) 0 ;
  Handle< Quote > *arg2 = 0 ;
  ext::shared_ptr< CmsSpreadCouponPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CmsSpreadCouponPricer > *)jarg1;
  arg1 = (CmsSpreadCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->setCorrelation((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_CmsSpreadCouponPricer_setCorrelation__SWIG_1(void * jarg1) {
  CmsSpreadCouponPricer *arg1 = (CmsSpreadCouponPricer *) 0 ;
  ext::shared_ptr< CmsSpreadCouponPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CmsSpreadCouponPricer > *)jarg1;
  arg1 = (CmsSpreadCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (arg1)->setCorrelation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_CmsSpreadCouponPricer(void * jarg1) {
  CmsSpreadCouponPricer *arg1 = (CmsSpreadCouponPricer *) 0 ;
  ext::shared_ptr< CmsSpreadCouponPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CmsSpreadCouponPricer > *)jarg1;
  arg1 = (CmsSpreadCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LognormalCmsSpreadPricer__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, void * jarg5, double jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< CmsCouponPricer > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Size arg4 ;
  SwigValueWrapper< ext::optional< enum VolatilityType > > arg5 ;
  Real arg6 ;
  Real arg7 ;
  ext::shared_ptr< CmsCouponPricer > tempnull1 ;
  ext::optional< VolatilityType > const *argp5 ;
  LognormalCmsSpreadPricer *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CmsCouponPricer > *)jarg1 : &tempnull1; 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Size)jarg4; 
  argp5 = (ext::optional< VolatilityType > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< VolatilityType > const", 0);
    return 0;
  }
  arg5 = *argp5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (LognormalCmsSpreadPricer *)new LognormalCmsSpreadPricer((ext::shared_ptr< CmsCouponPricer > const &)*arg1,(Handle< Quote > const &)*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 ? new ext::shared_ptr<  LognormalCmsSpreadPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LognormalCmsSpreadPricer__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, void * jarg5, double jarg6) {
  void * jresult ;
  ext::shared_ptr< CmsCouponPricer > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Size arg4 ;
  SwigValueWrapper< ext::optional< enum VolatilityType > > arg5 ;
  Real arg6 ;
  ext::shared_ptr< CmsCouponPricer > tempnull1 ;
  ext::optional< VolatilityType > const *argp5 ;
  LognormalCmsSpreadPricer *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CmsCouponPricer > *)jarg1 : &tempnull1; 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Size)jarg4; 
  argp5 = (ext::optional< VolatilityType > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< VolatilityType > const", 0);
    return 0;
  }
  arg5 = *argp5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (LognormalCmsSpreadPricer *)new LognormalCmsSpreadPricer((ext::shared_ptr< CmsCouponPricer > const &)*arg1,(Handle< Quote > 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 = result ? new ext::shared_ptr<  LognormalCmsSpreadPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LognormalCmsSpreadPricer__SWIG_2(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, void * jarg5) {
  void * jresult ;
  ext::shared_ptr< CmsCouponPricer > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Size arg4 ;
  SwigValueWrapper< ext::optional< enum VolatilityType > > arg5 ;
  ext::shared_ptr< CmsCouponPricer > tempnull1 ;
  ext::optional< VolatilityType > const *argp5 ;
  LognormalCmsSpreadPricer *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CmsCouponPricer > *)jarg1 : &tempnull1; 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Size)jarg4; 
  argp5 = (ext::optional< VolatilityType > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< VolatilityType > const", 0);
    return 0;
  }
  arg5 = *argp5; 
  {
    try {
      result = (LognormalCmsSpreadPricer *)new LognormalCmsSpreadPricer((ext::shared_ptr< CmsCouponPricer > const &)*arg1,(Handle< Quote > const &)*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 ? new ext::shared_ptr<  LognormalCmsSpreadPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LognormalCmsSpreadPricer__SWIG_3(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< CmsCouponPricer > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Size arg4 ;
  ext::shared_ptr< CmsCouponPricer > tempnull1 ;
  LognormalCmsSpreadPricer *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CmsCouponPricer > *)jarg1 : &tempnull1; 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (LognormalCmsSpreadPricer *)new LognormalCmsSpreadPricer((ext::shared_ptr< CmsCouponPricer > const &)*arg1,(Handle< Quote > 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 = result ? new ext::shared_ptr<  LognormalCmsSpreadPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LognormalCmsSpreadPricer__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< CmsCouponPricer > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempnull1 ;
  LognormalCmsSpreadPricer *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CmsCouponPricer > *)jarg1 : &tempnull1; 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (LognormalCmsSpreadPricer *)new LognormalCmsSpreadPricer((ext::shared_ptr< CmsCouponPricer > 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 = result ? new ext::shared_ptr<  LognormalCmsSpreadPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LognormalCmsSpreadPricer__SWIG_5(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< CmsCouponPricer > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempnull1 ;
  LognormalCmsSpreadPricer *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CmsCouponPricer > *)jarg1 : &tempnull1; 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (LognormalCmsSpreadPricer *)new LognormalCmsSpreadPricer((ext::shared_ptr< CmsCouponPricer > 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 = result ? new ext::shared_ptr<  LognormalCmsSpreadPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LognormalCmsSpreadPricer_swapletPrice(void * jarg1) {
  double jresult ;
  LognormalCmsSpreadPricer *arg1 = (LognormalCmsSpreadPricer *) 0 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const LognormalCmsSpreadPricer > *)jarg1;
  arg1 = (LognormalCmsSpreadPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((LognormalCmsSpreadPricer const *)arg1)->swapletPrice();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LognormalCmsSpreadPricer_swapletRate(void * jarg1) {
  double jresult ;
  LognormalCmsSpreadPricer *arg1 = (LognormalCmsSpreadPricer *) 0 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const LognormalCmsSpreadPricer > *)jarg1;
  arg1 = (LognormalCmsSpreadPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((LognormalCmsSpreadPricer const *)arg1)->swapletRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LognormalCmsSpreadPricer_capletPrice(void * jarg1, double jarg2) {
  double jresult ;
  LognormalCmsSpreadPricer *arg1 = (LognormalCmsSpreadPricer *) 0 ;
  Rate arg2 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const LognormalCmsSpreadPricer > *)jarg1;
  arg1 = (LognormalCmsSpreadPricer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  {
    try {
      result = (Real)((LognormalCmsSpreadPricer const *)arg1)->capletPrice(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LognormalCmsSpreadPricer_capletRate(void * jarg1, double jarg2) {
  double jresult ;
  LognormalCmsSpreadPricer *arg1 = (LognormalCmsSpreadPricer *) 0 ;
  Rate arg2 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const LognormalCmsSpreadPricer > *)jarg1;
  arg1 = (LognormalCmsSpreadPricer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  {
    try {
      result = (Rate)((LognormalCmsSpreadPricer const *)arg1)->capletRate(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LognormalCmsSpreadPricer_floorletPrice(void * jarg1, double jarg2) {
  double jresult ;
  LognormalCmsSpreadPricer *arg1 = (LognormalCmsSpreadPricer *) 0 ;
  Rate arg2 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const LognormalCmsSpreadPricer > *)jarg1;
  arg1 = (LognormalCmsSpreadPricer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  {
    try {
      result = (Real)((LognormalCmsSpreadPricer const *)arg1)->floorletPrice(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_LognormalCmsSpreadPricer_floorletRate(void * jarg1, double jarg2) {
  double jresult ;
  LognormalCmsSpreadPricer *arg1 = (LognormalCmsSpreadPricer *) 0 ;
  Rate arg2 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const LognormalCmsSpreadPricer > *)jarg1;
  arg1 = (LognormalCmsSpreadPricer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  {
    try {
      result = (Rate)((LognormalCmsSpreadPricer const *)arg1)->floorletRate(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_LognormalCmsSpreadPricer(void * jarg1) {
  LognormalCmsSpreadPricer *arg1 = (LognormalCmsSpreadPricer *) 0 ;
  ext::shared_ptr< LognormalCmsSpreadPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  LognormalCmsSpreadPricer > *)jarg1;
  arg1 = (LognormalCmsSpreadPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_EquityCashFlowPricer(void * jarg1) {
  EquityCashFlowPricer *arg1 = (EquityCashFlowPricer *) 0 ;
  ext::shared_ptr< EquityCashFlowPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EquityCashFlowPricer > *)jarg1;
  arg1 = (EquityCashFlowPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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__SWIG_1(void * jarg1, void * jarg2) {
  Leg *arg1 = 0 ;
  ext::shared_ptr< EquityCashFlowPricer > *arg2 = 0 ;
  ext::shared_ptr< EquityCashFlowPricer > tempnull2 ;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return ;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< EquityCashFlowPricer > *)jarg2 : &tempnull2; 
  {
    try {
      setCouponPricer((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(ext::shared_ptr< EquityCashFlowPricer > 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_EquityCashFlow__SWIG_0(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< EquityIndex > arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  bool arg6 ;
  EquityCashFlow *result = 0 ;
  
  arg1 = (Real)jarg1; 
  if (jarg2) arg2 = *(ext::shared_ptr< EquityIndex > *)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (EquityCashFlow *)new EquityCashFlow(arg1,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 ? new ext::shared_ptr<  EquityCashFlow >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EquityCashFlow__SWIG_1(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< EquityIndex > arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  EquityCashFlow *result = 0 ;
  
  arg1 = (Real)jarg1; 
  if (jarg2) arg2 = *(ext::shared_ptr< EquityIndex > *)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EquityCashFlow *)new EquityCashFlow(arg1,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 ? new ext::shared_ptr<  EquityCashFlow >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_EquityCashFlow_setPricer(void * jarg1, void * jarg2) {
  EquityCashFlow *arg1 = (EquityCashFlow *) 0 ;
  ext::shared_ptr< EquityCashFlowPricer > *arg2 = 0 ;
  ext::shared_ptr< EquityCashFlow > *smartarg1 = 0 ;
  ext::shared_ptr< EquityCashFlowPricer > tempnull2 ;
  
  
  smartarg1 = (ext::shared_ptr<  EquityCashFlow > *)jarg1;
  arg1 = (EquityCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (ext::shared_ptr< EquityCashFlowPricer > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->setPricer((ext::shared_ptr< EquityCashFlowPricer > 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_EquityCashFlow(void * jarg1) {
  EquityCashFlow *arg1 = (EquityCashFlow *) 0 ;
  ext::shared_ptr< EquityCashFlow > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EquityCashFlow > *)jarg1;
  arg1 = (EquityCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EquityQuantoCashFlowPricer(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< YieldTermStructure > arg1 ;
  Handle< BlackVolTermStructure > arg2 ;
  Handle< BlackVolTermStructure > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > *argp1 ;
  Handle< BlackVolTermStructure > *argp2 ;
  Handle< BlackVolTermStructure > *argp3 ;
  Handle< Quote > *argp4 ;
  EquityQuantoCashFlowPricer *result = 0 ;
  
  argp1 = (Handle< YieldTermStructure > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg1 = *argp1; 
  argp2 = (Handle< BlackVolTermStructure > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< BlackVolTermStructure >", 0);
    return 0;
  }
  arg2 = *argp2; 
  argp3 = (Handle< BlackVolTermStructure > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< BlackVolTermStructure >", 0);
    return 0;
  }
  arg3 = *argp3; 
  argp4 = (Handle< Quote > *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg4 = *argp4; 
  {
    try {
      result = (EquityQuantoCashFlowPricer *)new EquityQuantoCashFlowPricer(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 ? new ext::shared_ptr<  EquityQuantoCashFlowPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EquityQuantoCashFlowPricer(void * jarg1) {
  EquityQuantoCashFlowPricer *arg1 = (EquityQuantoCashFlowPricer *) 0 ;
  ext::shared_ptr< EquityQuantoCashFlowPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EquityQuantoCashFlowPricer > *)jarg1;
  arg1 = (EquityQuantoCashFlowPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 * jarg7, void * jarg8, int jarg9, unsigned int jarg10, void * jarg11, int jarg12, int jarg13, int jarg14) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  DayCounter *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  Period *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  bool arg10 ;
  Calendar *arg11 = 0 ;
  Integer arg12 ;
  Compounding arg13 ;
  Frequency arg14 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (Calendar *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg9 = (BusinessDayConvention)jarg9; 
  arg10 = jarg10 ? true : false; 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg12 = (Integer)jarg12; 
  arg13 = (Compounding)jarg13; 
  arg14 = (Frequency)jarg14; 
  {
    try {
      result = _FixedRateLeg((Schedule const &)*arg1,(DayCounter const &)*arg2,(std::vector< double > const &)*arg3,(std::vector< double > const &)*arg4,arg5,(DayCounter const &)*arg6,(Period const &)*arg7,(Calendar const &)*arg8,arg9,arg10,(Calendar 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateLeg__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, unsigned int jarg10, void * jarg11, int jarg12, int jarg13) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  DayCounter *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  Period *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  bool arg10 ;
  Calendar *arg11 = 0 ;
  Integer arg12 ;
  Compounding arg13 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (Calendar *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg9 = (BusinessDayConvention)jarg9; 
  arg10 = jarg10 ? true : false; 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg12 = (Integer)jarg12; 
  arg13 = (Compounding)jarg13; 
  {
    try {
      result = _FixedRateLeg((Schedule const &)*arg1,(DayCounter const &)*arg2,(std::vector< double > const &)*arg3,(std::vector< double > const &)*arg4,arg5,(DayCounter const &)*arg6,(Period const &)*arg7,(Calendar const &)*arg8,arg9,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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateLeg__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, unsigned int jarg10, void * jarg11, int jarg12) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  DayCounter *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  Period *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  bool arg10 ;
  Calendar *arg11 = 0 ;
  Integer arg12 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (Calendar *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg9 = (BusinessDayConvention)jarg9; 
  arg10 = jarg10 ? true : false; 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg12 = (Integer)jarg12; 
  {
    try {
      result = _FixedRateLeg((Schedule const &)*arg1,(DayCounter const &)*arg2,(std::vector< double > const &)*arg3,(std::vector< double > const &)*arg4,arg5,(DayCounter const &)*arg6,(Period const &)*arg7,(Calendar const &)*arg8,arg9,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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateLeg__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, unsigned int jarg10, void * jarg11) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  DayCounter *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  Period *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  bool arg10 ;
  Calendar *arg11 = 0 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (Calendar *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg9 = (BusinessDayConvention)jarg9; 
  arg10 = jarg10 ? true : false; 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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,(Period const &)*arg7,(Calendar const &)*arg8,arg9,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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateLeg__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, unsigned int jarg10) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  DayCounter *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  Period *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  bool arg10 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (Calendar *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg9 = (BusinessDayConvention)jarg9; 
  arg10 = jarg10 ? true : false; 
  {
    try {
      result = _FixedRateLeg((Schedule const &)*arg1,(DayCounter const &)*arg2,(std::vector< double > const &)*arg3,(std::vector< double > const &)*arg4,arg5,(DayCounter const &)*arg6,(Period const &)*arg7,(Calendar 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateLeg__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  DayCounter *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  Period *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (Calendar *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg9 = (BusinessDayConvention)jarg9; 
  {
    try {
      result = _FixedRateLeg((Schedule const &)*arg1,(DayCounter const &)*arg2,(std::vector< double > const &)*arg3,(std::vector< double > const &)*arg4,arg5,(DayCounter const &)*arg6,(Period const &)*arg7,(Calendar 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateLeg__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  DayCounter *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  Period *arg7 = 0 ;
  Calendar *arg8 = 0 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (Calendar *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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,(Period 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateLeg__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  DayCounter *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  Period *arg7 = 0 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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,(Period 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateLeg__SWIG_8(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 & is null", 0);
    return 0;
  } 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateLeg__SWIG_9(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 & is null", 0);
    return 0;
  } 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateLeg__SWIG_10(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 & is null", 0);
    return 0;
  } 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & 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(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 * jarg12, void * jarg13, int jarg14, unsigned int jarg15, void * jarg16, int jarg17, void * jarg18) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  bool arg15 ;
  Calendar *arg16 = 0 ;
  Integer arg17 ;
  SwigValueWrapper< ext::optional< bool > > arg18 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  ext::optional< bool > *argp18 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  arg15 = jarg15 ? true : false; 
  arg16 = (Calendar *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg17 = (Integer)jarg17; 
  argp18 = (ext::optional< bool > *)jarg18; 
  if (!argp18) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg18 = *argp18; 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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,(Period const &)*arg12,(Calendar const &)*arg13,arg14,arg15,(Calendar const &)*arg16,arg17,SWIG_STD_MOVE(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 = new 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, unsigned int jarg11, void * jarg12, void * jarg13, int jarg14, unsigned int jarg15, void * jarg16, int jarg17) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  bool arg15 ;
  Calendar *arg16 = 0 ;
  Integer arg17 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  arg15 = jarg15 ? true : false; 
  arg16 = (Calendar *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg17 = (Integer)jarg17; 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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,(Period const &)*arg12,(Calendar const &)*arg13,arg14,arg15,(Calendar const &)*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 = new 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 * jarg10, unsigned int jarg11, void * jarg12, void * jarg13, int jarg14, unsigned int jarg15, void * jarg16) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  bool arg15 ;
  Calendar *arg16 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  arg15 = jarg15 ? true : false; 
  arg16 = (Calendar *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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,(Period const &)*arg12,(Calendar const &)*arg13,arg14,arg15,(Calendar 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 = new 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 * jarg9, void * jarg10, unsigned int jarg11, void * jarg12, void * jarg13, int jarg14, unsigned int jarg15) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  bool arg15 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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,(Period const &)*arg12,(Calendar const &)*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 = new 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 * jarg8, void * jarg9, void * jarg10, unsigned int jarg11, void * jarg12, void * jarg13, int jarg14) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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,(Period const &)*arg12,(Calendar 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 = new 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 * jarg7, void * jarg8, void * jarg9, void * jarg10, unsigned int jarg11, void * jarg12, void * jarg13) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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,(Period 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9, void * jarg10, unsigned int jarg11, void * jarg12) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Period *arg12 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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,(Period 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_7(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 ;
  ext::shared_ptr< IborIndex > *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 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_8(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 ;
  ext::shared_ptr< IborIndex > *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 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_9(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 ;
  ext::shared_ptr< IborIndex > *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 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_10(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 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  std::vector< Spread > *arg8 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_12(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_13(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_14(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_IborLeg__SWIG_15(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  {
    try {
      result = _IborLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightLeg__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, unsigned int jarg8, int jarg9, void * jarg10, int jarg11) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Real > *arg6 = 0 ;
  std::vector< Spread > *arg7 = 0 ;
  bool arg8 ;
  RateAveraging::Type arg9 ;
  Calendar *arg10 = 0 ;
  Integer arg11 ;
  ext::shared_ptr< OvernightIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< OvernightIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Spread > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = (RateAveraging::Type)jarg9; 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg11 = (Integer)jarg11; 
  {
    try {
      result = _OvernightLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< OvernightIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< double > const &)*arg6,(std::vector< double > const &)*arg7,arg8,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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightLeg__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, unsigned int jarg8, int jarg9, void * jarg10) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Real > *arg6 = 0 ;
  std::vector< Spread > *arg7 = 0 ;
  bool arg8 ;
  RateAveraging::Type arg9 ;
  Calendar *arg10 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< OvernightIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Spread > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = (RateAveraging::Type)jarg9; 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _OvernightLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< OvernightIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< double > const &)*arg6,(std::vector< double > const &)*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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightLeg__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, unsigned int jarg8, int jarg9) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Real > *arg6 = 0 ;
  std::vector< Spread > *arg7 = 0 ;
  bool arg8 ;
  RateAveraging::Type arg9 ;
  ext::shared_ptr< OvernightIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< OvernightIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Spread > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = (RateAveraging::Type)jarg9; 
  {
    try {
      result = _OvernightLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< OvernightIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< double > const &)*arg6,(std::vector< double > 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightLeg__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, unsigned int jarg8) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Real > *arg6 = 0 ;
  std::vector< Spread > *arg7 = 0 ;
  bool arg8 ;
  ext::shared_ptr< OvernightIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< OvernightIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Spread > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = _OvernightLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< OvernightIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< double > const &)*arg6,(std::vector< double > 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightLeg__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 ;
  ext::shared_ptr< OvernightIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Real > *arg6 = 0 ;
  std::vector< Spread > *arg7 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< OvernightIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Spread > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _OvernightLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< OvernightIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< double > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightLeg__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Real > *arg6 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< OvernightIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _OvernightLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< OvernightIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< double > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightLeg__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  ext::shared_ptr< OvernightIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< OvernightIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  {
    try {
      result = _OvernightLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< OvernightIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightLeg__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< OvernightIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _OvernightLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< OvernightIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightLeg__SWIG_8(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< OvernightIndex > *)jarg3 : &tempnull3; 
  {
    try {
      result = _OvernightLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< OvernightIndex > 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(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 * jarg12, void * jarg13, int jarg14, unsigned int jarg15) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *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 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  bool arg15 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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,(Period const &)*arg12,(Calendar const &)*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 = new 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, unsigned int jarg11, void * jarg12, void * jarg13, int jarg14) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *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 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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,(Period const &)*arg12,(Calendar 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 = new 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 * jarg10, unsigned int jarg11, void * jarg12, void * jarg13) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *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 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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,(Period 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 = new 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 * jarg9, void * jarg10, unsigned int jarg11, void * jarg12) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *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 ;
  Period *arg12 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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,(Period 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 = new 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 * jarg8, void * jarg9, void * jarg10, unsigned int jarg11) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *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 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_5(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 ;
  ext::shared_ptr< SwapIndex > *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 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_6(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 ;
  ext::shared_ptr< SwapIndex > *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 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_7(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 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  std::vector< Spread > *arg8 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_8(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_9(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsLeg__SWIG_12(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  {
    try {
      result = _CmsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(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 * jarg11, void * jarg12, int jarg13, unsigned int jarg14) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *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 ;
  Period *arg11 = 0 ;
  Calendar *arg12 = 0 ;
  BusinessDayConvention arg13 ;
  bool arg14 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg12 = (Calendar *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg13 = (BusinessDayConvention)jarg13; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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,(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 = new 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 * jarg10, void * jarg11, void * jarg12, int jarg13) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *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 ;
  Period *arg11 = 0 ;
  Calendar *arg12 = 0 ;
  BusinessDayConvention arg13 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg12 = (Calendar *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg13 = (BusinessDayConvention)jarg13; 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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,(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 = new 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 * jarg9, void * jarg10, void * jarg11, void * jarg12) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *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 ;
  Period *arg11 = 0 ;
  Calendar *arg12 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg12 = (Calendar *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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,(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 = new 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 * jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *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 ;
  Period *arg11 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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,(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 = new 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 * jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *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 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsZeroLeg__SWIG_5(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 ;
  ext::shared_ptr< SwapIndex > *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 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsZeroLeg__SWIG_6(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 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  std::vector< Spread > *arg8 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsZeroLeg__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsZeroLeg__SWIG_8(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsZeroLeg__SWIG_9(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsZeroLeg__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsZeroLeg__SWIG_11(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapIndex > *)jarg3 : &tempnull3; 
  {
    try {
      result = _CmsZeroLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsSpreadLeg__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 ;
  ext::shared_ptr< SwapSpreadIndex > *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 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = _CmsSpreadLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapSpreadIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsSpreadLeg__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 ;
  ext::shared_ptr< SwapSpreadIndex > *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 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsSpreadLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapSpreadIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsSpreadLeg__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 ;
  ext::shared_ptr< SwapSpreadIndex > *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 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsSpreadLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapSpreadIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsSpreadLeg__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 ;
  ext::shared_ptr< SwapSpreadIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  std::vector< Spread > *arg8 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsSpreadLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapSpreadIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsSpreadLeg__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 ;
  ext::shared_ptr< SwapSpreadIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsSpreadLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapSpreadIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsSpreadLeg__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Natural > *arg6 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (std::vector< Natural > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsSpreadLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapSpreadIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsSpreadLeg__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  {
    try {
      result = _CmsSpreadLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapSpreadIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsSpreadLeg__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CmsSpreadLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapSpreadIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CmsSpreadLeg__SWIG_8(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > *arg3 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< SwapSpreadIndex > *)jarg3 : &tempnull3; 
  {
    try {
      result = _CmsSpreadLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapSpreadIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsLeg__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13, int jarg14, unsigned int jarg15, int jarg16) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Calendar *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Natural > *arg8 = 0 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  std::vector< Spread > *arg11 = 0 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  bool arg15 ;
  RateAveraging::Type arg16 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Calendar *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Natural > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Spread > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  arg15 = jarg15 ? true : false; 
  arg16 = (RateAveraging::Type)jarg16; 
  {
    try {
      result = _SubPeriodsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(Calendar const &)*arg6,arg7,(std::vector< unsigned int > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,(Period const &)*arg12,(Calendar const &)*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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsLeg__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13, int jarg14, unsigned int jarg15) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Calendar *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Natural > *arg8 = 0 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  std::vector< Spread > *arg11 = 0 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  bool arg15 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Calendar *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Natural > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Spread > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = _SubPeriodsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(Calendar const &)*arg6,arg7,(std::vector< unsigned int > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,(Period const &)*arg12,(Calendar const &)*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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsLeg__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13, int jarg14) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Calendar *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Natural > *arg8 = 0 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  std::vector< Spread > *arg11 = 0 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Calendar *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Natural > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Spread > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  {
    try {
      result = _SubPeriodsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(Calendar const &)*arg6,arg7,(std::vector< unsigned int > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,(Period const &)*arg12,(Calendar 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsLeg__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Calendar *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Natural > *arg8 = 0 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  std::vector< Spread > *arg11 = 0 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Calendar *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Natural > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Spread > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _SubPeriodsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(Calendar const &)*arg6,arg7,(std::vector< unsigned int > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,(Period 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsLeg__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Calendar *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Natural > *arg8 = 0 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  std::vector< Spread > *arg11 = 0 ;
  Period *arg12 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Calendar *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Natural > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Spread > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _SubPeriodsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(Calendar const &)*arg6,arg7,(std::vector< unsigned int > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,(Period 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsLeg__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Calendar *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Natural > *arg8 = 0 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  std::vector< Spread > *arg11 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Calendar *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Natural > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Spread > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _SubPeriodsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(Calendar const &)*arg6,arg7,(std::vector< unsigned int > 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsLeg__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Calendar *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Natural > *arg8 = 0 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Calendar *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Natural > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _SubPeriodsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(Calendar const &)*arg6,arg7,(std::vector< unsigned int > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsLeg__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Calendar *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Natural > *arg8 = 0 ;
  std::vector< Real > *arg9 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Calendar *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Natural > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _SubPeriodsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(Calendar const &)*arg6,arg7,(std::vector< unsigned int > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsLeg__SWIG_8(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, int jarg7, void * jarg8) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Calendar *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Natural > *arg8 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Calendar *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Natural > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Natural > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _SubPeriodsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(Calendar const &)*arg6,arg7,(std::vector< unsigned int > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsLeg__SWIG_9(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, int jarg7) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Calendar *arg6 = 0 ;
  Integer arg7 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Calendar *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg7 = (Integer)jarg7; 
  {
    try {
      result = _SubPeriodsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(Calendar 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsLeg__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  Calendar *arg6 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Calendar *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _SubPeriodsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(Calendar 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsLeg__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  {
    try {
      result = _SubPeriodsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsLeg__SWIG_12(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _SubPeriodsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SubPeriodsLeg__SWIG_13(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  {
    try {
      result = _SubPeriodsLeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > 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(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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = CashFlows::startDate((std::vector< ext::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(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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = CashFlows::maturityDate((std::vector< ext::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlows_previousCashFlowDate__SWIG_0(void * jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  Leg *arg1 = 0 ;
  bool arg2 ;
  Date arg3 ;
  Date *argp3 ;
  Date result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  argp3 = (Date *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = CashFlows::previousCashFlowDate((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlows_previousCashFlowDate__SWIG_1(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  Leg *arg1 = 0 ;
  bool arg2 ;
  Date result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = CashFlows::previousCashFlowDate((std::vector< ext::shared_ptr< CashFlow > > 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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlows_nextCashFlowDate__SWIG_0(void * jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  Leg *arg1 = 0 ;
  bool arg2 ;
  Date arg3 ;
  Date *argp3 ;
  Date result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  argp3 = (Date *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = CashFlows::nextCashFlowDate((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlows_nextCashFlowDate__SWIG_1(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  Leg *arg1 = 0 ;
  bool arg2 ;
  Date result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = CashFlows::nextCashFlowDate((std::vector< ext::shared_ptr< CashFlow > > 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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CashFlows_previousCashFlowAmount__SWIG_0(void * jarg1, unsigned int jarg2, void * jarg3) {
  double jresult ;
  Leg *arg1 = 0 ;
  bool arg2 ;
  Date arg3 ;
  Date *argp3 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  argp3 = (Date *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (Real)CashFlows::previousCashFlowAmount((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_previousCashFlowAmount__SWIG_1(void * jarg1, unsigned int jarg2) {
  double jresult ;
  Leg *arg1 = 0 ;
  bool arg2 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (Real)CashFlows::previousCashFlowAmount((std::vector< ext::shared_ptr< CashFlow > > 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_CashFlows_nextCashFlowAmount__SWIG_0(void * jarg1, unsigned int jarg2, void * jarg3) {
  double jresult ;
  Leg *arg1 = 0 ;
  bool arg2 ;
  Date arg3 ;
  Date *argp3 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  argp3 = (Date *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (Real)CashFlows::nextCashFlowAmount((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_nextCashFlowAmount__SWIG_1(void * jarg1, unsigned int jarg2) {
  double jresult ;
  Leg *arg1 = 0 ;
  bool arg2 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (Real)CashFlows::nextCashFlowAmount((std::vector< ext::shared_ptr< CashFlow > > 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_CashFlows_previousCashFlow__SWIG_0(void * jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  Leg *arg1 = 0 ;
  bool arg2 ;
  Date arg3 ;
  Date *argp3 ;
  ext::shared_ptr< CashFlow > result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  argp3 = (Date *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = CashFlows_previousCashFlow__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< CashFlow >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlows_previousCashFlow__SWIG_1(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  Leg *arg1 = 0 ;
  bool arg2 ;
  ext::shared_ptr< CashFlow > result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = CashFlows_previousCashFlow__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > 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 ? new ext::shared_ptr< CashFlow >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlows_nextCashFlow__SWIG_0(void * jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  Leg *arg1 = 0 ;
  bool arg2 ;
  Date arg3 ;
  Date *argp3 ;
  ext::shared_ptr< CashFlow > result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  argp3 = (Date *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = CashFlows_nextCashFlow__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< CashFlow >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlows_nextCashFlow__SWIG_1(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  Leg *arg1 = 0 ;
  bool arg2 ;
  ext::shared_ptr< CashFlow > result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = CashFlows_nextCashFlow__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > 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 ? new ext::shared_ptr< CashFlow >(result) : 0; 
  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 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Spread arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date *arg8 = 0 ;
  Date *arg9 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Spread)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CashFlows_npv__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(ext::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 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Spread arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date *arg8 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Spread)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CashFlows_npv__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(ext::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 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Spread arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Spread)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (Real)CashFlows_npv__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CashFlows_npv__SWIG_3((std::vector< ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CashFlows_npv__SWIG_3((std::vector< ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)CashFlows_npv__SWIG_3((std::vector< ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)CashFlows::npv((std::vector< ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (Real)CashFlows::npv((std::vector< ext::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 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CashFlows_bps__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(ext::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 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CashFlows_bps__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(ext::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 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  Real result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)CashFlows_bps__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CashFlows_bps__SWIG_3((std::vector< ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)CashFlows_bps__SWIG_3((std::vector< ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)CashFlows_bps__SWIG_3((std::vector< ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)CashFlows::bps((std::vector< ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (Real)CashFlows::bps((std::vector< ext::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 void * SWIGSTDCALL CSharp_QuantLib_CashFlows_npvbps__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  std::pair< Real,Real > result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = CashFlows_npvbps__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(ext::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 = new std::pair< Real,Real >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlows_npvbps__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4) {
  void * jresult ;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  std::pair< Real,Real > result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = CashFlows_npvbps__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(ext::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 = new std::pair< Real,Real >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlows_npvbps__SWIG_2(void * jarg1, void * jarg2, unsigned int jarg3) {
  void * jresult ;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  std::pair< Real,Real > result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = CashFlows_npvbps__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(ext::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 = new std::pair< Real,Real >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlows_npvbps__SWIG_3(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  std::pair< Real,Real > result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = CashFlows_npvbps__SWIG_3((std::vector< ext::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 = new std::pair< Real,Real >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlows_npvbps__SWIG_4(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4) {
  void * jresult ;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  std::pair< Real,Real > result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = CashFlows_npvbps__SWIG_3((std::vector< ext::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 = new std::pair< Real,Real >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CashFlows_npvbps__SWIG_5(void * jarg1, void * jarg2, unsigned int jarg3) {
  void * jresult ;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  std::pair< Real,Real > result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = CashFlows_npvbps__SWIG_3((std::vector< ext::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 = new std::pair< Real,Real >(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 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Real arg6 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  Rate result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (Rate)CashFlows_atmRate__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(ext::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 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  Rate result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)CashFlows_atmRate__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(ext::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 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  Rate result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)CashFlows_atmRate__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(ext::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 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  Rate result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Rate)CashFlows_atmRate__SWIG_0((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9,SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9,SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (Rate)CashFlows::yield((std::vector< ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,arg4,SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & is null", 0);
    return 0;
  } 
  arg3 = (Duration::Type)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Time)CashFlows::duration((std::vector< ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7,SWIG_STD_MOVE(arg8),SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7,SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)CashFlows::convexity((std::vector< ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (Real)CashFlows::convexity((std::vector< ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Real)CashFlows::basisPointValue((std::vector< ext::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 & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(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 & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (Real)CashFlows::basisPointValue((std::vector< ext::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 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date arg8 ;
  Date arg9 ;
  Real arg10 ;
  Size arg11 ;
  Rate arg12 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  Date *argp8 ;
  Date *argp9 ;
  Spread result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,SWIG_STD_MOVE(arg8),SWIG_STD_MOVE(arg9),arg10,SWIG_STD_MOVE(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 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date arg8 ;
  Date arg9 ;
  Real arg10 ;
  Size arg11 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  Date *argp8 ;
  Date *argp9 ;
  Spread result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,SWIG_STD_MOVE(arg8),SWIG_STD_MOVE(arg9),arg10,SWIG_STD_MOVE(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 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date arg8 ;
  Date arg9 ;
  Real arg10 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  Date *argp8 ;
  Date *argp9 ;
  Spread result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,SWIG_STD_MOVE(arg8),SWIG_STD_MOVE(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 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date arg8 ;
  Date arg9 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  Date *argp8 ;
  Date *argp9 ;
  Spread result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,SWIG_STD_MOVE(arg8),SWIG_STD_MOVE(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 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date arg8 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  Date *argp8 ;
  Spread result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,SWIG_STD_MOVE(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 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  Spread result;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (Spread)CashFlows::zSpread((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,arg2,(ext::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_delete_Dividend(void * jarg1) {
  Dividend *arg1 = (Dividend *) 0 ;
  ext::shared_ptr< Dividend > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Dividend > *)jarg1;
  arg1 = (Dividend *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedDividend(double jarg1, void * jarg2) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  FixedDividend *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedDividend *)new FixedDividend(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 ? new ext::shared_ptr<  FixedDividend >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FixedDividend(void * jarg1) {
  FixedDividend *arg1 = (FixedDividend *) 0 ;
  ext::shared_ptr< FixedDividend > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FixedDividend > *)jarg1;
  arg1 = (FixedDividend *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  FractionalDividend *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FractionalDividend *)new FractionalDividend(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 ? new ext::shared_ptr<  FractionalDividend >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FractionalDividend(void * jarg1) {
  FractionalDividend *arg1 = (FractionalDividend *) 0 ;
  ext::shared_ptr< FractionalDividend > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FractionalDividend > *)jarg1;
  arg1 = (FractionalDividend *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  
  arg1 = (std::vector< ext::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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  ext::shared_ptr< Dividend > *arg2 = 0 ;
  ext::shared_ptr< Dividend > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Dividend > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (std::vector< ext::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< ext::shared_ptr< Dividend > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< Dividend > > *)new std::vector< ext::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< ext::shared_ptr< Dividend > > *arg1 = 0 ;
  std::vector< ext::shared_ptr< Dividend > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Dividend > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< ext::shared_ptr< Dividend > > *)new std::vector< ext::shared_ptr< Dividend > >((std::vector< ext::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< ext::shared_ptr< Dividend > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Dividend > > *)new_std_vector_Sl_ext_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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< Dividend > result;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_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 = result ? new ext::shared_ptr< Dividend >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DividendSchedule_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Dividend > >::value_type *) &std_vector_Sl_ext_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 = *result ? new std::vector< ext::shared_ptr< Dividend > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DividendSchedule_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< Dividend > *arg3 = 0 ;
  ext::shared_ptr< Dividend > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< Dividend > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__setitem(arg1,arg2,(ext::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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< Dividend > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Dividend > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__AddRange(arg1,(std::vector< ext::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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< Dividend > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Dividend > > *)std_vector_Sl_ext_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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< Dividend > *arg3 = 0 ;
  ext::shared_ptr< Dividend > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< Dividend > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__Insert(arg1,arg2,(ext::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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Dividend > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Dividend > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Dividend > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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 ;
  ext::shared_ptr< Dividend > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< Dividend > tempnull1 ;
  std::vector< ext::shared_ptr< Dividend > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Dividend > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Dividend > > *)std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__Repeat((ext::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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Dividend > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Dividend > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Dividend > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  ext::shared_ptr< Dividend > *arg2 = 0 ;
  ext::shared_ptr< Dividend > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Dividend > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__Contains(arg1,(ext::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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  ext::shared_ptr< Dividend > *arg2 = 0 ;
  ext::shared_ptr< Dividend > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Dividend > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__IndexOf(arg1,(ext::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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  ext::shared_ptr< Dividend > *arg2 = 0 ;
  ext::shared_ptr< Dividend > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Dividend > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__LastIndexOf(arg1,(ext::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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  ext::shared_ptr< Dividend > *arg2 = 0 ;
  ext::shared_ptr< Dividend > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Dividend > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__Remove(arg1,(ext::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< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  
  arg1 = (std::vector< ext::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_Exercise(int jarg1) {
  void * jresult ;
  Exercise::Type arg1 ;
  Exercise *result = 0 ;
  
  arg1 = (Exercise::Type)jarg1; 
  {
    try {
      result = (Exercise *)new Exercise(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  Exercise >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Exercise_type(void * jarg1) {
  int jresult ;
  Exercise *arg1 = (Exercise *) 0 ;
  ext::shared_ptr< Exercise const > *smartarg1 = 0 ;
  Exercise::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const Exercise > *)jarg1;
  arg1 = (Exercise *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_date(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  Exercise *arg1 = (Exercise *) 0 ;
  Size arg2 ;
  ext::shared_ptr< Exercise > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr<  Exercise > *)jarg1;
  arg1 = (Exercise *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Exercise_dateAt(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  Exercise *arg1 = (Exercise *) 0 ;
  Size arg2 ;
  ext::shared_ptr< Exercise > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr<  Exercise > *)jarg1;
  arg1 = (Exercise *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (arg1)->dateAt(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Exercise_dates(void * jarg1) {
  void * jresult ;
  Exercise *arg1 = (Exercise *) 0 ;
  ext::shared_ptr< Exercise > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Exercise > *)jarg1;
  arg1 = (Exercise *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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 ;
  Exercise *arg1 = (Exercise *) 0 ;
  ext::shared_ptr< Exercise const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const Exercise > *)jarg1;
  arg1 = (Exercise *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Exercise(void * jarg1) {
  Exercise *arg1 = (Exercise *) 0 ;
  ext::shared_ptr< Exercise > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Exercise > *)jarg1;
  arg1 = (Exercise *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EuropeanExercise(void * jarg1) {
  void * jresult ;
  Date *arg1 = 0 ;
  EuropeanExercise *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EuropeanExercise *)new EuropeanExercise((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 ? new ext::shared_ptr<  EuropeanExercise >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EuropeanExercise(void * jarg1) {
  EuropeanExercise *arg1 = (EuropeanExercise *) 0 ;
  ext::shared_ptr< EuropeanExercise > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EuropeanExercise > *)jarg1;
  arg1 = (EuropeanExercise *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  AmericanExercise *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (AmericanExercise *)new AmericanExercise((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 = result ? new ext::shared_ptr<  AmericanExercise >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmericanExercise__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  AmericanExercise *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmericanExercise *)new AmericanExercise((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 = result ? new ext::shared_ptr<  AmericanExercise >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AmericanExercise(void * jarg1) {
  AmericanExercise *arg1 = (AmericanExercise *) 0 ;
  ext::shared_ptr< AmericanExercise > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AmericanExercise > *)jarg1;
  arg1 = (AmericanExercise *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  BermudanExercise *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (BermudanExercise *)new BermudanExercise((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 = result ? new ext::shared_ptr<  BermudanExercise >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BermudanExercise__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  BermudanExercise *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BermudanExercise *)new BermudanExercise((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 = result ? new ext::shared_ptr<  BermudanExercise >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BermudanExercise(void * jarg1) {
  BermudanExercise *arg1 = (BermudanExercise *) 0 ;
  ext::shared_ptr< BermudanExercise > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BermudanExercise > *)jarg1;
  arg1 = (BermudanExercise *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Exercise *arg1 = 0 ;
  std::vector< Real > arg2 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  std::vector< Real > const *argp2 ;
  RebatedExercise *result = 0 ;
  
  
  arg1 = (Exercise *)(((ext::shared_ptr< const Exercise > *)jarg1) ? ((ext::shared_ptr< const Exercise > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Exercise const & reference is null", 0);
    return 0;
  } 
  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 & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  {
    try {
      result = (RebatedExercise *)new RebatedExercise((Exercise const &)*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 = result ? new ext::shared_ptr<  RebatedExercise >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RebatedExercise__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4) {
  void * jresult ;
  Exercise *arg1 = 0 ;
  std::vector< Real > arg2 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  std::vector< Real > const *argp2 ;
  RebatedExercise *result = 0 ;
  
  
  arg1 = (Exercise *)(((ext::shared_ptr< const Exercise > *)jarg1) ? ((ext::shared_ptr< const Exercise > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Exercise const & reference is null", 0);
    return 0;
  } 
  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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = (RebatedExercise *)new RebatedExercise((Exercise const &)*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 = result ? new ext::shared_ptr<  RebatedExercise >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RebatedExercise__SWIG_2(void * jarg1, void * jarg2, unsigned int jarg3) {
  void * jresult ;
  Exercise *arg1 = 0 ;
  std::vector< Real > arg2 ;
  Natural arg3 ;
  std::vector< Real > const *argp2 ;
  RebatedExercise *result = 0 ;
  
  
  arg1 = (Exercise *)(((ext::shared_ptr< const Exercise > *)jarg1) ? ((ext::shared_ptr< const Exercise > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Exercise const & reference is null", 0);
    return 0;
  } 
  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 = (RebatedExercise *)new RebatedExercise((Exercise 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 ? new ext::shared_ptr<  RebatedExercise >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RebatedExercise__SWIG_3(void * jarg1, void * jarg2) {
  void * jresult ;
  Exercise *arg1 = 0 ;
  std::vector< Real > arg2 ;
  std::vector< Real > const *argp2 ;
  RebatedExercise *result = 0 ;
  
  
  arg1 = (Exercise *)(((ext::shared_ptr< const Exercise > *)jarg1) ? ((ext::shared_ptr< const Exercise > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Exercise const & reference is null", 0);
    return 0;
  } 
  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 = (RebatedExercise *)new RebatedExercise((Exercise 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 ? new ext::shared_ptr<  RebatedExercise >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RebatedExercise(void * jarg1) {
  RebatedExercise *arg1 = (RebatedExercise *) 0 ;
  ext::shared_ptr< RebatedExercise > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  RebatedExercise > *)jarg1;
  arg1 = (RebatedExercise *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwingExercise(void * jarg1) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  SwingExercise *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwingExercise *)new SwingExercise((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 = result ? new ext::shared_ptr<  SwingExercise >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SwingExercise(void * jarg1) {
  SwingExercise *arg1 = (SwingExercise *) 0 ;
  ext::shared_ptr< SwingExercise > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SwingExercise > *)jarg1;
  arg1 = (SwingExercise *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (TimeGrid *)new_TimeGrid__SWIG_3((std::vector< double > const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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 unsigned long SWIGSTDCALL CSharp_QuantLib_StochasticProcess_size(void * jarg1) {
  unsigned long jresult ;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess > *)jarg1;
  arg1 = (StochasticProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((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_StochasticProcess_factors(void * jarg1) {
  unsigned long jresult ;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess > *)jarg1;
  arg1 = (StochasticProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((StochasticProcess const *)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 ;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess > *)jarg1;
  arg1 = (StochasticProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((StochasticProcess const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcess_drift(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess > *)jarg1;
  arg1 = (StochasticProcess *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((StochasticProcess const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcess_diffusion(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  Matrix result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess > *)jarg1;
  arg1 = (StochasticProcess *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((StochasticProcess const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcess_expectation(void * jarg1, double jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  Time arg4 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess > *)jarg1;
  arg1 = (StochasticProcess *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg4 = (Time)jarg4; 
  {
    try {
      result = ((StochasticProcess const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcess_stdDeviation(void * jarg1, double jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  Time arg4 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  Matrix result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess > *)jarg1;
  arg1 = (StochasticProcess *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg4 = (Time)jarg4; 
  {
    try {
      result = ((StochasticProcess const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcess_covariance(void * jarg1, double jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  Time arg4 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  Matrix result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess > *)jarg1;
  arg1 = (StochasticProcess *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg4 = (Time)jarg4; 
  {
    try {
      result = ((StochasticProcess const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcess_evolve(void * jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  Time arg4 ;
  Array *arg5 = 0 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess > *)jarg1;
  arg1 = (StochasticProcess *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg4 = (Time)jarg4; 
  arg5 = (Array *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((StochasticProcess const *)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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_StochasticProcess(void * jarg1) {
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  ext::shared_ptr< StochasticProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  StochasticProcess > *)jarg1;
  arg1 = (StochasticProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_Clear(void * jarg1) {
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  
  arg1 = (std::vector< ext::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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  ext::shared_ptr< StochasticProcess > *arg2 = 0 ;
  ext::shared_ptr< StochasticProcess > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StochasticProcess > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (std::vector< ext::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< ext::shared_ptr< StochasticProcess > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< StochasticProcess > > *)new std::vector< ext::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< ext::shared_ptr< StochasticProcess > > *arg1 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< StochasticProcess > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< ext::shared_ptr< StochasticProcess > > *)new std::vector< ext::shared_ptr< StochasticProcess > >((std::vector< ext::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< ext::shared_ptr< StochasticProcess > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StochasticProcess > > *)new_std_vector_Sl_ext_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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< StochasticProcess > result;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_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 = result ? new ext::shared_ptr< StochasticProcess >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StochasticProcess > >::value_type *) &std_vector_Sl_ext_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 = *result ? new std::vector< ext::shared_ptr< StochasticProcess > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StochasticProcessVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< StochasticProcess > *arg3 = 0 ;
  ext::shared_ptr< StochasticProcess > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< StochasticProcess > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__setitem(arg1,arg2,(ext::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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< StochasticProcess > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__AddRange(arg1,(std::vector< ext::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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< StochasticProcess > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StochasticProcess > > *)std_vector_Sl_ext_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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< StochasticProcess > *arg3 = 0 ;
  ext::shared_ptr< StochasticProcess > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< StochasticProcess > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__Insert(arg1,arg2,(ext::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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< StochasticProcess > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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 ;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< StochasticProcess > tempnull1 ;
  std::vector< ext::shared_ptr< StochasticProcess > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StochasticProcess > > *)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__Repeat((ext::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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< StochasticProcess > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  ext::shared_ptr< StochasticProcess > *arg2 = 0 ;
  ext::shared_ptr< StochasticProcess > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StochasticProcess > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__Contains(arg1,(ext::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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  ext::shared_ptr< StochasticProcess > *arg2 = 0 ;
  ext::shared_ptr< StochasticProcess > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StochasticProcess > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__IndexOf(arg1,(ext::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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  ext::shared_ptr< StochasticProcess > *arg2 = 0 ;
  ext::shared_ptr< StochasticProcess > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StochasticProcess > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__LastIndexOf(arg1,(ext::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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  ext::shared_ptr< StochasticProcess > *arg2 = 0 ;
  ext::shared_ptr< StochasticProcess > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StochasticProcess > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__Remove(arg1,(ext::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< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  
  arg1 = (std::vector< ext::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 ;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  ext::shared_ptr< StochasticProcess1D const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess1D > *)jarg1;
  arg1 = (StochasticProcess1D *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((StochasticProcess1D const *)arg1)->x0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  Time arg2 ;
  Real arg3 ;
  ext::shared_ptr< StochasticProcess1D const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess1D > *)jarg1;
  arg1 = (StochasticProcess1D *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((StochasticProcess1D const *)arg1)->drift(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 ;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  Time arg2 ;
  Real arg3 ;
  ext::shared_ptr< StochasticProcess1D const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess1D > *)jarg1;
  arg1 = (StochasticProcess1D *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((StochasticProcess1D const *)arg1)->diffusion(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 ;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Time arg4 ;
  ext::shared_ptr< StochasticProcess1D const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess1D > *)jarg1;
  arg1 = (StochasticProcess1D *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Time)jarg4; 
  {
    try {
      result = (Real)((StochasticProcess1D const *)arg1)->expectation(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 ;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Time arg4 ;
  ext::shared_ptr< StochasticProcess1D const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess1D > *)jarg1;
  arg1 = (StochasticProcess1D *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Time)jarg4; 
  {
    try {
      result = (Real)((StochasticProcess1D const *)arg1)->stdDeviation(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 ;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Time arg4 ;
  ext::shared_ptr< StochasticProcess1D const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess1D > *)jarg1;
  arg1 = (StochasticProcess1D *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Time)jarg4; 
  {
    try {
      result = (Real)((StochasticProcess1D const *)arg1)->variance(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 ;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Time arg4 ;
  Real arg5 ;
  ext::shared_ptr< StochasticProcess1D const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess1D > *)jarg1;
  arg1 = (StochasticProcess1D *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Time)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)((StochasticProcess1D const *)arg1)->evolve(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 ;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< StochasticProcess1D const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const StochasticProcess1D > *)jarg1;
  arg1 = (StochasticProcess1D *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((StochasticProcess1D const *)arg1)->apply(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) {
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  ext::shared_ptr< StochasticProcess1D > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  StochasticProcess1D > *)jarg1;
  arg1 = (StochasticProcess1D *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StochasticProcess1DVector_Clear(void * jarg1) {
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)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_StochasticProcess1DVector_Add(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  ext::shared_ptr< StochasticProcess1D > *arg2 = 0 ;
  ext::shared_ptr< StochasticProcess1D > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StochasticProcess1D > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::shared_ptr< StochasticProcess1D > 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_StochasticProcess1DVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< StochasticProcess1D > > 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_StochasticProcess1DVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< StochasticProcess1D > > 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_StochasticProcess1DVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< StochasticProcess1D > >::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_StochasticProcess1DVector__SWIG_0() {
  void * jresult ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)new std::vector< ext::shared_ptr< StochasticProcess1D > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_StochasticProcess1DVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)new_std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_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_StochasticProcess1DVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< StochasticProcess1D > result;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_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 = result ? new ext::shared_ptr< StochasticProcess1D >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StochasticProcess1DVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_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 = *result ? new std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_StochasticProcess1DVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< StochasticProcess1D > *arg3 = 0 ;
  ext::shared_ptr< StochasticProcess1D > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< StochasticProcess1D > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__setitem(arg1,arg2,(ext::shared_ptr< StochasticProcess1D > 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_StochasticProcess1DVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< StochasticProcess1D > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__AddRange(arg1,(std::vector< ext::shared_ptr< StochasticProcess1D > > 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_StochasticProcess1DVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_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_StochasticProcess1DVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< StochasticProcess1D > *arg3 = 0 ;
  ext::shared_ptr< StochasticProcess1D > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< StochasticProcess1D > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__Insert(arg1,arg2,(ext::shared_ptr< StochasticProcess1D > 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_StochasticProcess1DVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< StochasticProcess1D > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::shared_ptr< StochasticProcess1D > > 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_StochasticProcess1DVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_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_StochasticProcess1DVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_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_StochasticProcess1DVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< StochasticProcess1D > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< StochasticProcess1D > tempnull1 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess1D > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__Repeat((ext::shared_ptr< StochasticProcess1D > 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_StochasticProcess1DVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_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_StochasticProcess1DVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_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_StochasticProcess1DVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< StochasticProcess1D > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::shared_ptr< StochasticProcess1D > > 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_StochasticProcess1DVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  ext::shared_ptr< StochasticProcess1D > *arg2 = 0 ;
  ext::shared_ptr< StochasticProcess1D > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StochasticProcess1D > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__Contains(arg1,(ext::shared_ptr< StochasticProcess1D > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_StochasticProcess1DVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  ext::shared_ptr< StochasticProcess1D > *arg2 = 0 ;
  ext::shared_ptr< StochasticProcess1D > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StochasticProcess1D > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__IndexOf(arg1,(ext::shared_ptr< StochasticProcess1D > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_StochasticProcess1DVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  ext::shared_ptr< StochasticProcess1D > *arg2 = 0 ;
  ext::shared_ptr< StochasticProcess1D > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StochasticProcess1D > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__LastIndexOf(arg1,(ext::shared_ptr< StochasticProcess1D > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_StochasticProcess1DVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  ext::shared_ptr< StochasticProcess1D > *arg2 = 0 ;
  ext::shared_ptr< StochasticProcess1D > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StochasticProcess1D > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__Remove(arg1,(ext::shared_ptr< StochasticProcess1D > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_StochasticProcess1DVector(void * jarg1) {
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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__SWIG_0(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 ;
  GeneralizedBlackScholesProcess *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< BlackVolTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (GeneralizedBlackScholesProcess *)new GeneralizedBlackScholesProcess((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 = result ? new ext::shared_ptr<  GeneralizedBlackScholesProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GeneralizedBlackScholesProcess__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< BlackVolTermStructure > *arg4 = 0 ;
  Handle< LocalVolTermStructure > *arg5 = 0 ;
  GeneralizedBlackScholesProcess *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< BlackVolTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< LocalVolTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< LocalVolTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (GeneralizedBlackScholesProcess *)new GeneralizedBlackScholesProcess((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< BlackVolTermStructure > const &)*arg4,(Handle< LocalVolTermStructure > 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 ? new ext::shared_ptr<  GeneralizedBlackScholesProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GeneralizedBlackScholesProcess_stateVariable(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcess *arg1 = (GeneralizedBlackScholesProcess *) 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *smartarg1 = 0 ;
  Handle< Quote > result;
  
  
  smartarg1 = (ext::shared_ptr<  GeneralizedBlackScholesProcess > *)jarg1;
  arg1 = (GeneralizedBlackScholesProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->stateVariable();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GeneralizedBlackScholesProcess_dividendYield(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcess *arg1 = (GeneralizedBlackScholesProcess *) 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *smartarg1 = 0 ;
  Handle< YieldTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr<  GeneralizedBlackScholesProcess > *)jarg1;
  arg1 = (GeneralizedBlackScholesProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->dividendYield();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GeneralizedBlackScholesProcess_riskFreeRate(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcess *arg1 = (GeneralizedBlackScholesProcess *) 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *smartarg1 = 0 ;
  Handle< YieldTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr<  GeneralizedBlackScholesProcess > *)jarg1;
  arg1 = (GeneralizedBlackScholesProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->riskFreeRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GeneralizedBlackScholesProcess_blackVolatility(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcess *arg1 = (GeneralizedBlackScholesProcess *) 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *smartarg1 = 0 ;
  Handle< BlackVolTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr<  GeneralizedBlackScholesProcess > *)jarg1;
  arg1 = (GeneralizedBlackScholesProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->blackVolatility();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GeneralizedBlackScholesProcess_localVolatility(void * jarg1) {
  void * jresult ;
  GeneralizedBlackScholesProcess *arg1 = (GeneralizedBlackScholesProcess *) 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *smartarg1 = 0 ;
  Handle< LocalVolTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr<  GeneralizedBlackScholesProcess > *)jarg1;
  arg1 = (GeneralizedBlackScholesProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->localVolatility();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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< LocalVolTermStructure >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GeneralizedBlackScholesProcess(void * jarg1) {
  GeneralizedBlackScholesProcess *arg1 = (GeneralizedBlackScholesProcess *) 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GeneralizedBlackScholesProcess > *)jarg1;
  arg1 = (GeneralizedBlackScholesProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  BlackScholesProcess *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< BlackVolTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackScholesProcess *)new BlackScholesProcess((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 = result ? new ext::shared_ptr<  BlackScholesProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackScholesProcess(void * jarg1) {
  BlackScholesProcess *arg1 = (BlackScholesProcess *) 0 ;
  ext::shared_ptr< BlackScholesProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackScholesProcess > *)jarg1;
  arg1 = (BlackScholesProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  BlackScholesMertonProcess *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< BlackVolTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackScholesMertonProcess *)new BlackScholesMertonProcess((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 = result ? new ext::shared_ptr<  BlackScholesMertonProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackScholesMertonProcess(void * jarg1) {
  BlackScholesMertonProcess *arg1 = (BlackScholesMertonProcess *) 0 ;
  ext::shared_ptr< BlackScholesMertonProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackScholesMertonProcess > *)jarg1;
  arg1 = (BlackScholesMertonProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  BlackProcess *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< BlackVolTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackProcess *)new BlackProcess((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 = result ? new ext::shared_ptr<  BlackProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackProcess(void * jarg1) {
  BlackProcess *arg1 = (BlackProcess *) 0 ;
  ext::shared_ptr< BlackProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackProcess > *)jarg1;
  arg1 = (BlackProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  GarmanKohlagenProcess *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< BlackVolTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (GarmanKohlagenProcess *)new GarmanKohlagenProcess((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 = result ? new ext::shared_ptr<  GarmanKohlagenProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GarmanKohlagenProcess(void * jarg1) {
  GarmanKohlagenProcess *arg1 = (GarmanKohlagenProcess *) 0 ;
  ext::shared_ptr< GarmanKohlagenProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GarmanKohlagenProcess > *)jarg1;
  arg1 = (GarmanKohlagenProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Merton76Process *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< BlackVolTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (Handle< Quote > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg7 = (Handle< Quote > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Merton76Process *)new Merton76Process((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 = result ? new ext::shared_ptr<  Merton76Process >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Merton76Process(void * jarg1) {
  Merton76Process *arg1 = (Merton76Process *) 0 ;
  ext::shared_ptr< Merton76Process > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Merton76Process > *)jarg1;
  arg1 = (Merton76Process *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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< ext::shared_ptr< StochasticProcess1D > > *arg1 = 0 ;
  Matrix *arg2 = 0 ;
  StochasticProcessArray *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< StochasticProcess1D > > const & is null", 0);
    return 0;
  } 
  arg2 = (Matrix *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (StochasticProcessArray *)new StochasticProcessArray((std::vector< ext::shared_ptr< StochasticProcess1D > > 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 = result ? new ext::shared_ptr<  StochasticProcessArray >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_StochasticProcessArray(void * jarg1) {
  StochasticProcessArray *arg1 = (StochasticProcessArray *) 0 ;
  ext::shared_ptr< StochasticProcessArray > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  StochasticProcessArray > *)jarg1;
  arg1 = (StochasticProcessArray *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  GeometricBrownianMotionProcess *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (GeometricBrownianMotionProcess *)new GeometricBrownianMotionProcess(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 ? new ext::shared_ptr<  GeometricBrownianMotionProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GeometricBrownianMotionProcess(void * jarg1) {
  GeometricBrownianMotionProcess *arg1 = (GeometricBrownianMotionProcess *) 0 ;
  ext::shared_ptr< GeometricBrownianMotionProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GeometricBrownianMotionProcess > *)jarg1;
  arg1 = (GeometricBrownianMotionProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  VarianceGammaProcess *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (VarianceGammaProcess *)new VarianceGammaProcess((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 = result ? new ext::shared_ptr<  VarianceGammaProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_VarianceGammaProcess(void * jarg1) {
  VarianceGammaProcess *arg1 = (VarianceGammaProcess *) 0 ;
  ext::shared_ptr< VarianceGammaProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  VarianceGammaProcess > *)jarg1;
  arg1 = (VarianceGammaProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, int jarg9) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  HestonProcess::Discretization arg9 ;
  HestonProcess *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (HestonProcess::Discretization)jarg9; 
  {
    try {
      result = (HestonProcess *)new HestonProcess((Handle< YieldTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< Quote > 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 ? new ext::shared_ptr<  HestonProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HestonProcess__SWIG_1(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 ;
  HestonProcess *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (HestonProcess *)new HestonProcess((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 = result ? new ext::shared_ptr<  HestonProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HestonProcess_s0(void * jarg1) {
  void * jresult ;
  HestonProcess *arg1 = (HestonProcess *) 0 ;
  ext::shared_ptr< HestonProcess > *smartarg1 = 0 ;
  Handle< Quote > result;
  
  
  smartarg1 = (ext::shared_ptr<  HestonProcess > *)jarg1;
  arg1 = (HestonProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->s0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HestonProcess_dividendYield(void * jarg1) {
  void * jresult ;
  HestonProcess *arg1 = (HestonProcess *) 0 ;
  ext::shared_ptr< HestonProcess > *smartarg1 = 0 ;
  Handle< YieldTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr<  HestonProcess > *)jarg1;
  arg1 = (HestonProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->dividendYield();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HestonProcess_riskFreeRate(void * jarg1) {
  void * jresult ;
  HestonProcess *arg1 = (HestonProcess *) 0 ;
  ext::shared_ptr< HestonProcess > *smartarg1 = 0 ;
  Handle< YieldTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr<  HestonProcess > *)jarg1;
  arg1 = (HestonProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->riskFreeRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HestonProcess(void * jarg1) {
  HestonProcess *arg1 = (HestonProcess *) 0 ;
  ext::shared_ptr< HestonProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  HestonProcess > *)jarg1;
  arg1 = (HestonProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  BatesProcess *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & 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 = (BatesProcess *)new BatesProcess((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 = result ? new ext::shared_ptr<  BatesProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BatesProcess(void * jarg1) {
  BatesProcess *arg1 = (BatesProcess *) 0 ;
  ext::shared_ptr< BatesProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BatesProcess > *)jarg1;
  arg1 = (BatesProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  HullWhiteProcess *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (HullWhiteProcess *)new HullWhiteProcess((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 = result ? new ext::shared_ptr<  HullWhiteProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HullWhiteProcess(void * jarg1) {
  HullWhiteProcess *arg1 = (HullWhiteProcess *) 0 ;
  ext::shared_ptr< HullWhiteProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  HullWhiteProcess > *)jarg1;
  arg1 = (HullWhiteProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  HullWhiteForwardProcess *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (HullWhiteForwardProcess *)new HullWhiteForwardProcess((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 = result ? new ext::shared_ptr<  HullWhiteForwardProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HullWhiteForwardProcess_alpha(void * jarg1, double jarg2) {
  double jresult ;
  HullWhiteForwardProcess *arg1 = (HullWhiteForwardProcess *) 0 ;
  Time arg2 ;
  ext::shared_ptr< HullWhiteForwardProcess const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const HullWhiteForwardProcess > *)jarg1;
  arg1 = (HullWhiteForwardProcess *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)((HullWhiteForwardProcess const *)arg1)->alpha(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  HullWhiteForwardProcess *arg1 = (HullWhiteForwardProcess *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  ext::shared_ptr< HullWhiteForwardProcess const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const HullWhiteForwardProcess > *)jarg1;
  arg1 = (HullWhiteForwardProcess *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)((HullWhiteForwardProcess const *)arg1)->M_T(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 ;
  HullWhiteForwardProcess *arg1 = (HullWhiteForwardProcess *) 0 ;
  Time arg2 ;
  Time arg3 ;
  ext::shared_ptr< HullWhiteForwardProcess const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const HullWhiteForwardProcess > *)jarg1;
  arg1 = (HullWhiteForwardProcess *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)((HullWhiteForwardProcess const *)arg1)->B(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) {
  HullWhiteForwardProcess *arg1 = (HullWhiteForwardProcess *) 0 ;
  Time arg2 ;
  ext::shared_ptr< HullWhiteForwardProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  HullWhiteForwardProcess > *)jarg1;
  arg1 = (HullWhiteForwardProcess *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      (arg1)->setForwardMeasureTime(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) {
  HullWhiteForwardProcess *arg1 = (HullWhiteForwardProcess *) 0 ;
  ext::shared_ptr< HullWhiteForwardProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  HullWhiteForwardProcess > *)jarg1;
  arg1 = (HullWhiteForwardProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_G2Process(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  G2Process *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (G2Process *)new G2Process(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 ? new ext::shared_ptr<  G2Process >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_G2Process(void * jarg1) {
  G2Process *arg1 = (G2Process *) 0 ;
  ext::shared_ptr< G2Process > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  G2Process > *)jarg1;
  arg1 = (G2Process *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_G2ForwardProcess(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  G2ForwardProcess *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (G2ForwardProcess *)new G2ForwardProcess(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 ? new ext::shared_ptr<  G2ForwardProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_G2ForwardProcess_setForwardMeasureTime(void * jarg1, double jarg2) {
  G2ForwardProcess *arg1 = (G2ForwardProcess *) 0 ;
  Time arg2 ;
  ext::shared_ptr< G2ForwardProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  G2ForwardProcess > *)jarg1;
  arg1 = (G2ForwardProcess *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      (arg1)->setForwardMeasureTime(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_G2ForwardProcess(void * jarg1) {
  G2ForwardProcess *arg1 = (G2ForwardProcess *) 0 ;
  ext::shared_ptr< G2ForwardProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  G2ForwardProcess > *)jarg1;
  arg1 = (G2ForwardProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  GsrProcess *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (GsrProcess *)new GsrProcess((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 = result ? new ext::shared_ptr<  GsrProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  GsrProcess *result = 0 ;
  
  arg1 = (Array *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (GsrProcess *)new GsrProcess((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 = result ? new ext::shared_ptr<  GsrProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_GsrProcess_sigma(void * jarg1, double jarg2) {
  double jresult ;
  GsrProcess *arg1 = (GsrProcess *) 0 ;
  Time arg2 ;
  ext::shared_ptr< GsrProcess > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  GsrProcess > *)jarg1;
  arg1 = (GsrProcess *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)(arg1)->sigma(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  GsrProcess *arg1 = (GsrProcess *) 0 ;
  Time arg2 ;
  ext::shared_ptr< GsrProcess > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  GsrProcess > *)jarg1;
  arg1 = (GsrProcess *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)(arg1)->reversion(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  GsrProcess *arg1 = (GsrProcess *) 0 ;
  Time arg2 ;
  ext::shared_ptr< GsrProcess > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  GsrProcess > *)jarg1;
  arg1 = (GsrProcess *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)(arg1)->y(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  GsrProcess *arg1 = (GsrProcess *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  ext::shared_ptr< GsrProcess > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  GsrProcess > *)jarg1;
  arg1 = (GsrProcess *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)(arg1)->G(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) {
  GsrProcess *arg1 = (GsrProcess *) 0 ;
  Time arg2 ;
  ext::shared_ptr< GsrProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GsrProcess > *)jarg1;
  arg1 = (GsrProcess *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      (arg1)->setForwardMeasureTime(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) {
  GsrProcess *arg1 = (GsrProcess *) 0 ;
  ext::shared_ptr< GsrProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GsrProcess > *)jarg1;
  arg1 = (GsrProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempnull1 ;
  ext::shared_ptr< GsrProcess > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_gsr_process((ext::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 = result ? new ext::shared_ptr< GsrProcess >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OrnsteinUhlenbeckProcess__SWIG_0(double jarg1, double jarg2, double jarg3, double jarg4) {
  void * jresult ;
  Real arg1 ;
  Volatility arg2 ;
  Real arg3 ;
  Real arg4 ;
  OrnsteinUhlenbeckProcess *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Volatility)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (OrnsteinUhlenbeckProcess *)new OrnsteinUhlenbeckProcess(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 ? new ext::shared_ptr<  OrnsteinUhlenbeckProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OrnsteinUhlenbeckProcess__SWIG_1(double jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Real arg1 ;
  Volatility arg2 ;
  Real arg3 ;
  OrnsteinUhlenbeckProcess *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Volatility)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (OrnsteinUhlenbeckProcess *)new OrnsteinUhlenbeckProcess(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 ? new ext::shared_ptr<  OrnsteinUhlenbeckProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OrnsteinUhlenbeckProcess__SWIG_2(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Volatility arg2 ;
  OrnsteinUhlenbeckProcess *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Volatility)jarg2; 
  {
    try {
      result = (OrnsteinUhlenbeckProcess *)new OrnsteinUhlenbeckProcess(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 ? new ext::shared_ptr<  OrnsteinUhlenbeckProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OrnsteinUhlenbeckProcess_speed(void * jarg1) {
  double jresult ;
  OrnsteinUhlenbeckProcess *arg1 = (OrnsteinUhlenbeckProcess *) 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OrnsteinUhlenbeckProcess > *)jarg1;
  arg1 = (OrnsteinUhlenbeckProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((OrnsteinUhlenbeckProcess const *)arg1)->speed();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OrnsteinUhlenbeckProcess_volatility(void * jarg1) {
  double jresult ;
  OrnsteinUhlenbeckProcess *arg1 = (OrnsteinUhlenbeckProcess *) 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OrnsteinUhlenbeckProcess > *)jarg1;
  arg1 = (OrnsteinUhlenbeckProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((OrnsteinUhlenbeckProcess 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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OrnsteinUhlenbeckProcess_level(void * jarg1) {
  double jresult ;
  OrnsteinUhlenbeckProcess *arg1 = (OrnsteinUhlenbeckProcess *) 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OrnsteinUhlenbeckProcess > *)jarg1;
  arg1 = (OrnsteinUhlenbeckProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((OrnsteinUhlenbeckProcess const *)arg1)->level();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_OrnsteinUhlenbeckProcess(void * jarg1) {
  OrnsteinUhlenbeckProcess *arg1 = (OrnsteinUhlenbeckProcess *) 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OrnsteinUhlenbeckProcess > *)jarg1;
  arg1 = (OrnsteinUhlenbeckProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExtendedOrnsteinUhlenbeckProcess__SWIG_0(double jarg1, double jarg2, double jarg3, void * jarg4, int jarg5, double jarg6) {
  void * jresult ;
  Real arg1 ;
  Volatility arg2 ;
  Real arg3 ;
  ext::function< Real (Real) > *arg4 = 0 ;
  ExtendedOrnsteinUhlenbeckProcess::Discretization arg5 ;
  Real arg6 ;
  ExtendedOrnsteinUhlenbeckProcess *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Volatility)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (ext::function< Real (Real) > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ext::function< Real (Real) > const & is null", 0);
    return 0;
  } 
  arg5 = (ExtendedOrnsteinUhlenbeckProcess::Discretization)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (ExtendedOrnsteinUhlenbeckProcess *)new ExtendedOrnsteinUhlenbeckProcess(arg1,arg2,arg3,(ext::function< Real (Real) > 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 ? new ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExtendedOrnsteinUhlenbeckProcess__SWIG_1(double jarg1, double jarg2, double jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  Real arg1 ;
  Volatility arg2 ;
  Real arg3 ;
  ext::function< Real (Real) > *arg4 = 0 ;
  ExtendedOrnsteinUhlenbeckProcess::Discretization arg5 ;
  ExtendedOrnsteinUhlenbeckProcess *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Volatility)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (ext::function< Real (Real) > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ext::function< Real (Real) > const & is null", 0);
    return 0;
  } 
  arg5 = (ExtendedOrnsteinUhlenbeckProcess::Discretization)jarg5; 
  {
    try {
      result = (ExtendedOrnsteinUhlenbeckProcess *)new ExtendedOrnsteinUhlenbeckProcess(arg1,arg2,arg3,(ext::function< Real (Real) > 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 ? new ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExtendedOrnsteinUhlenbeckProcess__SWIG_2(double jarg1, double jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  Real arg1 ;
  Volatility arg2 ;
  Real arg3 ;
  ext::function< Real (Real) > *arg4 = 0 ;
  ExtendedOrnsteinUhlenbeckProcess *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Volatility)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (ext::function< Real (Real) > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ext::function< Real (Real) > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ExtendedOrnsteinUhlenbeckProcess *)new ExtendedOrnsteinUhlenbeckProcess(arg1,arg2,arg3,(ext::function< Real (Real) > 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 ? new ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExtendedOrnsteinUhlenbeckProcess__SWIG_3(double jarg1, double jarg2, double jarg3, void * jarg4, double jarg5) {
  void * jresult ;
  Real arg1 ;
  Volatility arg2 ;
  Real arg3 ;
  UnaryFunctionDelegate *arg4 = (UnaryFunctionDelegate *) 0 ;
  Real arg5 ;
  ExtendedOrnsteinUhlenbeckProcess *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Volatility)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (UnaryFunctionDelegate *)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (ExtendedOrnsteinUhlenbeckProcess *)new_ExtendedOrnsteinUhlenbeckProcess__SWIG_3(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 ? new ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExtendedOrnsteinUhlenbeckProcess__SWIG_4(double jarg1, double jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  Real arg1 ;
  Volatility arg2 ;
  Real arg3 ;
  UnaryFunctionDelegate *arg4 = (UnaryFunctionDelegate *) 0 ;
  ExtendedOrnsteinUhlenbeckProcess *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Volatility)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (UnaryFunctionDelegate *)jarg4; 
  {
    try {
      result = (ExtendedOrnsteinUhlenbeckProcess *)new_ExtendedOrnsteinUhlenbeckProcess__SWIG_3(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 ? new ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ExtendedOrnsteinUhlenbeckProcess(void * jarg1) {
  ExtendedOrnsteinUhlenbeckProcess *arg1 = (ExtendedOrnsteinUhlenbeckProcess *) 0 ;
  ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess > *)jarg1;
  arg1 = (ExtendedOrnsteinUhlenbeckProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExtOUWithJumpsProcess(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  void * jresult ;
  ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > tempnull1 ;
  ExtOUWithJumpsProcess *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (ExtOUWithJumpsProcess *)new ExtOUWithJumpsProcess((ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > 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 ? new ext::shared_ptr<  ExtOUWithJumpsProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ExtOUWithJumpsProcess(void * jarg1) {
  ExtOUWithJumpsProcess *arg1 = (ExtOUWithJumpsProcess *) 0 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ExtOUWithJumpsProcess > *)jarg1;
  arg1 = (ExtOUWithJumpsProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KlugeExtOUProcess(double jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > *arg2 = 0 ;
  ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > *arg3 = 0 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > tempnull2 ;
  ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > tempnull3 ;
  KlugeExtOUProcess *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< ExtOUWithJumpsProcess > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > *)jarg3 : &tempnull3; 
  {
    try {
      result = (KlugeExtOUProcess *)new KlugeExtOUProcess(arg1,(ext::shared_ptr< ExtOUWithJumpsProcess > const &)*arg2,(ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > 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 ? new ext::shared_ptr<  KlugeExtOUProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_KlugeExtOUProcess(void * jarg1) {
  KlugeExtOUProcess *arg1 = (KlugeExtOUProcess *) 0 ;
  ext::shared_ptr< KlugeExtOUProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  KlugeExtOUProcess > *)jarg1;
  arg1 = (KlugeExtOUProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GJRGARCHProcess__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, double jarg9, double jarg10, int 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 ;
  GJRGARCHProcess::Discretization arg11 ;
  GJRGARCHProcess *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & 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 = (GJRGARCHProcess::Discretization)jarg11; 
  {
    try {
      result = (GJRGARCHProcess *)new GJRGARCHProcess((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 = result ? new ext::shared_ptr<  GJRGARCHProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GJRGARCHProcess__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, double jarg9, double jarg10) {
  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 ;
  GJRGARCHProcess *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & 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; 
  {
    try {
      result = (GJRGARCHProcess *)new GJRGARCHProcess((Handle< YieldTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< Quote > 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 ? new ext::shared_ptr<  GJRGARCHProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GJRGARCHProcess__SWIG_2(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, double jarg9) {
  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 ;
  GJRGARCHProcess *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (GJRGARCHProcess *)new GJRGARCHProcess((Handle< YieldTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< Quote > 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 ? new ext::shared_ptr<  GJRGARCHProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GJRGARCHProcess_s0(void * jarg1) {
  void * jresult ;
  GJRGARCHProcess *arg1 = (GJRGARCHProcess *) 0 ;
  ext::shared_ptr< GJRGARCHProcess > *smartarg1 = 0 ;
  Handle< Quote > result;
  
  
  smartarg1 = (ext::shared_ptr<  GJRGARCHProcess > *)jarg1;
  arg1 = (GJRGARCHProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->s0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GJRGARCHProcess_dividendYield(void * jarg1) {
  void * jresult ;
  GJRGARCHProcess *arg1 = (GJRGARCHProcess *) 0 ;
  ext::shared_ptr< GJRGARCHProcess > *smartarg1 = 0 ;
  Handle< YieldTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr<  GJRGARCHProcess > *)jarg1;
  arg1 = (GJRGARCHProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->dividendYield();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GJRGARCHProcess_riskFreeRate(void * jarg1) {
  void * jresult ;
  GJRGARCHProcess *arg1 = (GJRGARCHProcess *) 0 ;
  ext::shared_ptr< GJRGARCHProcess > *smartarg1 = 0 ;
  Handle< YieldTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr<  GJRGARCHProcess > *)jarg1;
  arg1 = (GJRGARCHProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->riskFreeRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GJRGARCHProcess(void * jarg1) {
  GJRGARCHProcess *arg1 = (GJRGARCHProcess *) 0 ;
  ext::shared_ptr< GJRGARCHProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GJRGARCHProcess > *)jarg1;
  arg1 = (GJRGARCHProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_LazyObject_recalculate(void * jarg1) {
  LazyObject *arg1 = (LazyObject *) 0 ;
  ext::shared_ptr< LazyObject > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  LazyObject > *)jarg1;
  arg1 = (LazyObject *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_LazyObject_freeze(void * jarg1) {
  LazyObject *arg1 = (LazyObject *) 0 ;
  ext::shared_ptr< LazyObject > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  LazyObject > *)jarg1;
  arg1 = (LazyObject *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_LazyObject_unfreeze(void * jarg1) {
  LazyObject *arg1 = (LazyObject *) 0 ;
  ext::shared_ptr< LazyObject > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  LazyObject > *)jarg1;
  arg1 = (LazyObject *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_LazyObject_forwardFirstNotificationOnly() {
  {
    try {
      LazyObject_forwardFirstNotificationOnly();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_LazyObject_alwaysForwardNotifications() {
  {
    try {
      LazyObject_alwaysForwardNotifications();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_LazyObject_forwardsAllNotifications() {
  unsigned int jresult ;
  bool result;
  
  {
    try {
      result = (bool)LazyObject_forwardsAllNotifications();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_LazyObject(void * jarg1) {
  LazyObject *arg1 = (LazyObject *) 0 ;
  ext::shared_ptr< LazyObject > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  LazyObject > *)jarg1;
  arg1 = (LazyObject *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_PricingEngine(void * jarg1) {
  PricingEngine *arg1 = (PricingEngine *) 0 ;
  ext::shared_ptr< PricingEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PricingEngine > *)jarg1;
  arg1 = (PricingEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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 ;
  Instrument *arg1 = (Instrument *) 0 ;
  ext::shared_ptr< Instrument const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Instrument > *)jarg1;
  arg1 = (Instrument *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((Instrument const *)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 ;
  Instrument *arg1 = (Instrument *) 0 ;
  ext::shared_ptr< Instrument const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Instrument > *)jarg1;
  arg1 = (Instrument *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((Instrument 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 unsigned int SWIGSTDCALL CSharp_QuantLib_Instrument_isExpired(void * jarg1) {
  unsigned int jresult ;
  Instrument *arg1 = (Instrument *) 0 ;
  ext::shared_ptr< Instrument const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const Instrument > *)jarg1;
  arg1 = (Instrument *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((Instrument const *)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) {
  Instrument *arg1 = (Instrument *) 0 ;
  ext::shared_ptr< PricingEngine > *arg2 = 0 ;
  ext::shared_ptr< Instrument > *smartarg1 = 0 ;
  ext::shared_ptr< PricingEngine > tempnull2 ;
  
  
  smartarg1 = (ext::shared_ptr<  Instrument > *)jarg1;
  arg1 = (Instrument *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (ext::shared_ptr< PricingEngine > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->setPricingEngine((ext::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_delete_Instrument(void * jarg1) {
  Instrument *arg1 = (Instrument *) 0 ;
  ext::shared_ptr< Instrument > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Instrument > *)jarg1;
  arg1 = (Instrument *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  
  arg1 = (std::vector< ext::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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  ext::shared_ptr< Instrument > *arg2 = 0 ;
  ext::shared_ptr< Instrument > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Instrument > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (std::vector< ext::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< ext::shared_ptr< Instrument > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< Instrument > > *)new std::vector< ext::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< ext::shared_ptr< Instrument > > *arg1 = 0 ;
  std::vector< ext::shared_ptr< Instrument > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Instrument > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< ext::shared_ptr< Instrument > > *)new std::vector< ext::shared_ptr< Instrument > >((std::vector< ext::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< ext::shared_ptr< Instrument > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Instrument > > *)new_std_vector_Sl_ext_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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< Instrument > result;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_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 = result ? new ext::shared_ptr< Instrument >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InstrumentVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Instrument > >::value_type *) &std_vector_Sl_ext_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 = *result ? new std::vector< ext::shared_ptr< Instrument > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InstrumentVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< Instrument > *arg3 = 0 ;
  ext::shared_ptr< Instrument > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< Instrument > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__setitem(arg1,arg2,(ext::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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< Instrument > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Instrument > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__AddRange(arg1,(std::vector< ext::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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< Instrument > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Instrument > > *)std_vector_Sl_ext_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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< Instrument > *arg3 = 0 ;
  ext::shared_ptr< Instrument > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< Instrument > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__Insert(arg1,arg2,(ext::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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Instrument > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Instrument > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Instrument > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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 ;
  ext::shared_ptr< Instrument > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< Instrument > tempnull1 ;
  std::vector< ext::shared_ptr< Instrument > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Instrument > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Instrument > > *)std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__Repeat((ext::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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Instrument > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Instrument > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Instrument > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  ext::shared_ptr< Instrument > *arg2 = 0 ;
  ext::shared_ptr< Instrument > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Instrument > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__Contains(arg1,(ext::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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  ext::shared_ptr< Instrument > *arg2 = 0 ;
  ext::shared_ptr< Instrument > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Instrument > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__IndexOf(arg1,(ext::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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  ext::shared_ptr< Instrument > *arg2 = 0 ;
  ext::shared_ptr< Instrument > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Instrument > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__LastIndexOf(arg1,(ext::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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  ext::shared_ptr< Instrument > *arg2 = 0 ;
  ext::shared_ptr< Instrument > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< Instrument > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Instrument > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__Remove(arg1,(ext::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< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  
  arg1 = (std::vector< ext::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 ;
  Stock *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Stock *)new Stock((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 = result ? new ext::shared_ptr<  Stock >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Stock(void * jarg1) {
  Stock *arg1 = (Stock *) 0 ;
  ext::shared_ptr< Stock > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Stock > *)jarg1;
  arg1 = (Stock *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  CompositeInstrument *result = 0 ;
  
  {
    try {
      result = (CompositeInstrument *)new CompositeInstrument();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  CompositeInstrument >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CompositeInstrument_add__SWIG_0(void * jarg1, void * jarg2, double jarg3) {
  CompositeInstrument *arg1 = (CompositeInstrument *) 0 ;
  ext::shared_ptr< Instrument > *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< CompositeInstrument > *smartarg1 = 0 ;
  ext::shared_ptr< Instrument > tempnull2 ;
  
  
  smartarg1 = (ext::shared_ptr<  CompositeInstrument > *)jarg1;
  arg1 = (CompositeInstrument *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (ext::shared_ptr< Instrument > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  {
    try {
      (arg1)->add((ext::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) {
  CompositeInstrument *arg1 = (CompositeInstrument *) 0 ;
  ext::shared_ptr< Instrument > *arg2 = 0 ;
  ext::shared_ptr< CompositeInstrument > *smartarg1 = 0 ;
  ext::shared_ptr< Instrument > tempnull2 ;
  
  
  smartarg1 = (ext::shared_ptr<  CompositeInstrument > *)jarg1;
  arg1 = (CompositeInstrument *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (ext::shared_ptr< Instrument > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->add((ext::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) {
  CompositeInstrument *arg1 = (CompositeInstrument *) 0 ;
  ext::shared_ptr< Instrument > *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< CompositeInstrument > *smartarg1 = 0 ;
  ext::shared_ptr< Instrument > tempnull2 ;
  
  
  smartarg1 = (ext::shared_ptr<  CompositeInstrument > *)jarg1;
  arg1 = (CompositeInstrument *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (ext::shared_ptr< Instrument > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  {
    try {
      (arg1)->subtract((ext::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) {
  CompositeInstrument *arg1 = (CompositeInstrument *) 0 ;
  ext::shared_ptr< Instrument > *arg2 = 0 ;
  ext::shared_ptr< CompositeInstrument > *smartarg1 = 0 ;
  ext::shared_ptr< Instrument > tempnull2 ;
  
  
  smartarg1 = (ext::shared_ptr<  CompositeInstrument > *)jarg1;
  arg1 = (CompositeInstrument *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (ext::shared_ptr< Instrument > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->subtract((ext::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) {
  CompositeInstrument *arg1 = (CompositeInstrument *) 0 ;
  ext::shared_ptr< CompositeInstrument > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CompositeInstrument > *)jarg1;
  arg1 = (CompositeInstrument *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_calibrationError(void * jarg1) {
  double jresult ;
  CalibrationHelper *arg1 = (CalibrationHelper *) 0 ;
  ext::shared_ptr< CalibrationHelper > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CalibrationHelper > *)jarg1;
  arg1 = (CalibrationHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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 void SWIGSTDCALL CSharp_QuantLib_delete_CalibrationHelper(void * jarg1) {
  CalibrationHelper *arg1 = (CalibrationHelper *) 0 ;
  ext::shared_ptr< CalibrationHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CalibrationHelper > *)jarg1;
  arg1 = (CalibrationHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  
  arg1 = (std::vector< ext::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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  ext::shared_ptr< CalibrationHelper > *arg2 = 0 ;
  ext::shared_ptr< CalibrationHelper > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CalibrationHelper > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (std::vector< ext::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< ext::shared_ptr< CalibrationHelper > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< CalibrationHelper > > *)new std::vector< ext::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< ext::shared_ptr< CalibrationHelper > > *arg1 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< ext::shared_ptr< CalibrationHelper > > *)new std::vector< ext::shared_ptr< CalibrationHelper > >((std::vector< ext::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< ext::shared_ptr< CalibrationHelper > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CalibrationHelper > > *)new_std_vector_Sl_ext_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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< CalibrationHelper > result;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_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 = result ? new ext::shared_ptr< CalibrationHelper >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CalibrationHelper > >::value_type *) &std_vector_Sl_ext_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 = *result ? new std::vector< ext::shared_ptr< CalibrationHelper > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibrationHelperVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< CalibrationHelper > *arg3 = 0 ;
  ext::shared_ptr< CalibrationHelper > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< CalibrationHelper > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__setitem(arg1,arg2,(ext::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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__AddRange(arg1,(std::vector< ext::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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CalibrationHelper > > *)std_vector_Sl_ext_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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< CalibrationHelper > *arg3 = 0 ;
  ext::shared_ptr< CalibrationHelper > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< CalibrationHelper > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Insert(arg1,arg2,(ext::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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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 ;
  ext::shared_ptr< CalibrationHelper > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< CalibrationHelper > tempnull1 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CalibrationHelper > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CalibrationHelper > > *)std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Repeat((ext::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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  ext::shared_ptr< CalibrationHelper > *arg2 = 0 ;
  ext::shared_ptr< CalibrationHelper > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CalibrationHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Contains(arg1,(ext::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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  ext::shared_ptr< CalibrationHelper > *arg2 = 0 ;
  ext::shared_ptr< CalibrationHelper > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CalibrationHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__IndexOf(arg1,(ext::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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  ext::shared_ptr< CalibrationHelper > *arg2 = 0 ;
  ext::shared_ptr< CalibrationHelper > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CalibrationHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__LastIndexOf(arg1,(ext::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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  ext::shared_ptr< CalibrationHelper > *arg2 = 0 ;
  ext::shared_ptr< CalibrationHelper > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CalibrationHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__Remove(arg1,(ext::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< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  
  arg1 = (std::vector< ext::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_parameters(void * jarg1) {
  void * jresult ;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  ext::shared_ptr< CalibratedModel const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const CalibratedModel > *)jarg1;
  arg1 = (CalibratedModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((CalibratedModel 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 = new 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, void * jarg7) {
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  std::vector< bool > *arg7 = 0 ;
  ext::shared_ptr< CalibratedModel > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CalibratedModel > *)jarg1;
  arg1 = (CalibratedModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return ;
  } 
  arg7 = (std::vector< bool > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrate((std::vector< ext::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_CalibratedModel_calibrate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  ext::shared_ptr< CalibratedModel > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CalibratedModel > *)jarg1;
  arg1 = (CalibratedModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrate((std::vector< ext::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_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  ext::shared_ptr< CalibratedModel > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CalibratedModel > *)jarg1;
  arg1 = (CalibratedModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrate((std::vector< ext::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_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  ext::shared_ptr< CalibratedModel > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CalibratedModel > *)jarg1;
  arg1 = (CalibratedModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrate((std::vector< ext::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) {
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  Array *arg2 = 0 ;
  ext::shared_ptr< CalibratedModel > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CalibratedModel > *)jarg1;
  arg1 = (CalibratedModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 ;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  Array *arg2 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg3 = 0 ;
  ext::shared_ptr< CalibratedModel > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CalibratedModel > *)jarg1;
  arg1 = (CalibratedModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(arg1)->value((Array const &)*arg2,(std::vector< ext::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_CalibratedModel_constraint(void * jarg1) {
  void * jresult ;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  ext::shared_ptr< CalibratedModel const > *smartarg1 = 0 ;
  ext::shared_ptr< Constraint > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const CalibratedModel > *)jarg1;
  arg1 = (CalibratedModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (ext::shared_ptr< Constraint > *) &((CalibratedModel 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 = *result ? new ext::shared_ptr< Constraint >(*result) : 0; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_CalibratedModel_endCriteria(void * jarg1) {
  int jresult ;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  ext::shared_ptr< CalibratedModel const > *smartarg1 = 0 ;
  EndCriteria::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const CalibratedModel > *)jarg1;
  arg1 = (CalibratedModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (EndCriteria::Type)((CalibratedModel const *)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_CalibratedModel_problemValues(void * jarg1) {
  void * jresult ;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  ext::shared_ptr< CalibratedModel const > *smartarg1 = 0 ;
  Array *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const CalibratedModel > *)jarg1;
  arg1 = (CalibratedModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Array *) &((CalibratedModel const *)arg1)->problemValues();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_CalibratedModel_functionEvaluation(void * jarg1) {
  int jresult ;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  ext::shared_ptr< CalibratedModel const > *smartarg1 = 0 ;
  Integer result;
  
  
  smartarg1 = (ext::shared_ptr< const CalibratedModel > *)jarg1;
  arg1 = (CalibratedModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Integer)((CalibratedModel const *)arg1)->functionEvaluation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_CalibratedModel(void * jarg1) {
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  ext::shared_ptr< CalibratedModel > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CalibratedModel > *)jarg1;
  arg1 = (CalibratedModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_TermStructureConsistentModel_termStructure(void * jarg1) {
  void * jresult ;
  TermStructureConsistentModel *arg1 = (TermStructureConsistentModel *) 0 ;
  ext::shared_ptr< TermStructureConsistentModel const > *smartarg1 = 0 ;
  Handle< YieldTermStructure > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const TermStructureConsistentModel > *)jarg1;
  arg1 = (TermStructureConsistentModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Handle< YieldTermStructure > *) &((TermStructureConsistentModel const *)arg1)->termStructure();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TermStructureConsistentModel(void * jarg1) {
  TermStructureConsistentModel *arg1 = (TermStructureConsistentModel *) 0 ;
  ext::shared_ptr< TermStructureConsistentModel > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  TermStructureConsistentModel > *)jarg1;
  arg1 = (TermStructureConsistentModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CalibratedModelHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< CalibratedModel > *arg1 = 0 ;
  ext::shared_ptr< CalibratedModel > tempnull1 ;
  Handle< CalibratedModel > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CalibratedModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Handle< CalibratedModel > *)new Handle< CalibratedModel >((ext::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 ;
  ext::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 = result ? new ext::shared_ptr< CalibratedModel >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibratedModelHandle_currentLink(void * jarg1) {
  void * jresult ;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  ext::shared_ptr< CalibratedModel > result;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< CalibratedModel >(result) : 0; 
  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 ;
  ext::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 = result ? new ext::shared_ptr< Observable >(result) : 0; 
  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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibratedModelHandle_calibrate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  std::vector< ext::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< CalibratedModel > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return ;
  } 
  arg7 = (std::vector< bool > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< ext::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_CalibratedModelHandle_calibrate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  std::vector< ext::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< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< ext::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_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< ext::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_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< ext::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 & 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< ext::shared_ptr< CalibrationHelper > > *arg3 = 0 ;
  Real result;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->value((Array const &)*arg2,(std::vector< ext::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_CalibratedModelHandle_constraint(void * jarg1) {
  void * jresult ;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  ext::shared_ptr< Constraint > *result = 0 ;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  {
    try {
      result = (ext::shared_ptr< Constraint > *) &(*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 = *result ? new ext::shared_ptr< Constraint >(*result) : 0; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_CalibratedModelHandle_endCriteria(void * jarg1) {
  int jresult ;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  EndCriteria::Type result;
  
  arg1 = (Handle< CalibratedModel > *)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_CalibratedModelHandle_problemValues(void * jarg1) {
  void * jresult ;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  Array *result = 0 ;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  {
    try {
      result = (Array *) &(*arg1)->problemValues();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_CalibratedModelHandle_functionEvaluation(void * jarg1) {
  int jresult ;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  Integer result;
  
  arg1 = (Handle< CalibratedModel > *)jarg1; 
  {
    try {
      result = (Integer)(*arg1)->functionEvaluation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  ext::shared_ptr< CalibratedModel > *arg1 = 0 ;
  ext::shared_ptr< CalibratedModel > tempnull1 ;
  RelinkableHandle< CalibratedModel > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CalibratedModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (RelinkableHandle< CalibratedModel > *)new RelinkableHandle< CalibratedModel >((ext::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 ;
  ext::shared_ptr< CalibratedModel > *arg2 = 0 ;
  ext::shared_ptr< CalibratedModel > tempnull2 ;
  
  arg1 = (RelinkableHandle< CalibratedModel > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CalibratedModel > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->linkTo((ext::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_RelinkableCalibratedModelHandle_reset(void * jarg1) {
  RelinkableHandle< CalibratedModel > *arg1 = (RelinkableHandle< CalibratedModel > *) 0 ;
  
  arg1 = (RelinkableHandle< CalibratedModel > *)jarg1; 
  {
    try {
      RelinkableHandle_Sl_CalibratedModel_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_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_parameters(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 & 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 = new ext::shared_ptr< const Constraint >(result SWIG_NO_NULL_DELETER_0); 
  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 *)(((ext::shared_ptr< const Constraint > *)jarg1) ? ((ext::shared_ptr< const Constraint > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference 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 *)(((ext::shared_ptr< const Constraint > *)jarg2) ? ((ext::shared_ptr< const Constraint > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference 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 & is null", 0);
    return 0;
  } 
  
  arg2 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg2) ? ((ext::shared_ptr< const Constraint > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference 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 & 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 double SWIGSTDCALL CSharp_QuantLib_Payoff_call(void * jarg1, double jarg2) {
  double jresult ;
  Payoff *arg1 = (Payoff *) 0 ;
  Real arg2 ;
  ext::shared_ptr< Payoff const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Payoff > *)jarg1;
  arg1 = (Payoff *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((Payoff 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_Payoff(void * jarg1) {
  Payoff *arg1 = (Payoff *) 0 ;
  ext::shared_ptr< Payoff > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Payoff > *)jarg1;
  arg1 = (Payoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Option_payoff(void * jarg1) {
  void * jresult ;
  Option *arg1 = (Option *) 0 ;
  ext::shared_ptr< Option > *smartarg1 = 0 ;
  ext::shared_ptr< Payoff > result;
  
  
  smartarg1 = (ext::shared_ptr<  Option > *)jarg1;
  arg1 = (Option *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->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 = result ? new ext::shared_ptr< Payoff >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Option_exercise(void * jarg1) {
  void * jresult ;
  Option *arg1 = (Option *) 0 ;
  ext::shared_ptr< Option > *smartarg1 = 0 ;
  ext::shared_ptr< Exercise > result;
  
  
  smartarg1 = (ext::shared_ptr<  Option > *)jarg1;
  arg1 = (Option *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->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 = result ? new ext::shared_ptr< Exercise >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Option(void * jarg1) {
  Option *arg1 = (Option *) 0 ;
  ext::shared_ptr< Option > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Option > *)jarg1;
  arg1 = (Option *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_TypePayoff_optionType(void * jarg1) {
  int jresult ;
  TypePayoff *arg1 = (TypePayoff *) 0 ;
  ext::shared_ptr< TypePayoff > *smartarg1 = 0 ;
  Option::Type result;
  
  
  smartarg1 = (ext::shared_ptr<  TypePayoff > *)jarg1;
  arg1 = (TypePayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Option::Type)(arg1)->optionType();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_TypePayoff(void * jarg1) {
  TypePayoff *arg1 = (TypePayoff *) 0 ;
  ext::shared_ptr< TypePayoff > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  TypePayoff > *)jarg1;
  arg1 = (TypePayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingTypePayoff(int jarg1) {
  void * jresult ;
  Option::Type arg1 ;
  FloatingTypePayoff *result = 0 ;
  
  arg1 = (Option::Type)jarg1; 
  {
    try {
      result = (FloatingTypePayoff *)new FloatingTypePayoff(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FloatingTypePayoff >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FloatingTypePayoff_call__SWIG_0(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  FloatingTypePayoff *arg1 = (FloatingTypePayoff *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< FloatingTypePayoff const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingTypePayoff > *)jarg1;
  arg1 = (FloatingTypePayoff *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((FloatingTypePayoff const *)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_FloatingTypePayoff_call__SWIG_1(void * jarg1, double jarg2) {
  double jresult ;
  FloatingTypePayoff *arg1 = (FloatingTypePayoff *) 0 ;
  Real arg2 ;
  ext::shared_ptr< FloatingTypePayoff const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FloatingTypePayoff > *)jarg1;
  arg1 = (FloatingTypePayoff *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((FloatingTypePayoff 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_FloatingTypePayoff(void * jarg1) {
  FloatingTypePayoff *arg1 = (FloatingTypePayoff *) 0 ;
  ext::shared_ptr< FloatingTypePayoff > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FloatingTypePayoff > *)jarg1;
  arg1 = (FloatingTypePayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_StrikedTypePayoff_strike(void * jarg1) {
  double jresult ;
  StrikedTypePayoff *arg1 = (StrikedTypePayoff *) 0 ;
  ext::shared_ptr< StrikedTypePayoff > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  StrikedTypePayoff > *)jarg1;
  arg1 = (StrikedTypePayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->strike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_StrikedTypePayoff(void * jarg1) {
  StrikedTypePayoff *arg1 = (StrikedTypePayoff *) 0 ;
  ext::shared_ptr< StrikedTypePayoff > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  StrikedTypePayoff > *)jarg1;
  arg1 = (StrikedTypePayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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 ;
  DeltaVolQuote *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  arg4 = (DeltaVolQuote::DeltaType)jarg4; 
  {
    try {
      result = (DeltaVolQuote *)new DeltaVolQuote(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 = result ? new ext::shared_ptr<  DeltaVolQuote >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  DeltaVolQuote *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (DeltaVolQuote::DeltaType)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (DeltaVolQuote::AtmType)jarg4; 
  {
    try {
      result = (DeltaVolQuote *)new DeltaVolQuote((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 = result ? new ext::shared_ptr<  DeltaVolQuote >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_delta(void * jarg1) {
  double jresult ;
  DeltaVolQuote *arg1 = (DeltaVolQuote *) 0 ;
  ext::shared_ptr< DeltaVolQuote const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const DeltaVolQuote > *)jarg1;
  arg1 = (DeltaVolQuote *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((DeltaVolQuote const *)arg1)->delta();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_maturity(void * jarg1) {
  double jresult ;
  DeltaVolQuote *arg1 = (DeltaVolQuote *) 0 ;
  ext::shared_ptr< DeltaVolQuote const > *smartarg1 = 0 ;
  Time result;
  
  
  smartarg1 = (ext::shared_ptr< const DeltaVolQuote > *)jarg1;
  arg1 = (DeltaVolQuote *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Time)((DeltaVolQuote const *)arg1)->maturity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_DeltaVolQuote_atmType(void * jarg1) {
  int jresult ;
  DeltaVolQuote *arg1 = (DeltaVolQuote *) 0 ;
  ext::shared_ptr< DeltaVolQuote const > *smartarg1 = 0 ;
  DeltaVolQuote::AtmType result;
  
  
  smartarg1 = (ext::shared_ptr< const DeltaVolQuote > *)jarg1;
  arg1 = (DeltaVolQuote *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (DeltaVolQuote::AtmType)((DeltaVolQuote const *)arg1)->atmType();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_DeltaVolQuote_deltaType(void * jarg1) {
  int jresult ;
  DeltaVolQuote *arg1 = (DeltaVolQuote *) 0 ;
  ext::shared_ptr< DeltaVolQuote const > *smartarg1 = 0 ;
  DeltaVolQuote::DeltaType result;
  
  
  smartarg1 = (ext::shared_ptr< const DeltaVolQuote > *)jarg1;
  arg1 = (DeltaVolQuote *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (DeltaVolQuote::DeltaType)((DeltaVolQuote const *)arg1)->deltaType();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_DeltaVolQuote(void * jarg1) {
  DeltaVolQuote *arg1 = (DeltaVolQuote *) 0 ;
  ext::shared_ptr< DeltaVolQuote > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DeltaVolQuote > *)jarg1;
  arg1 = (DeltaVolQuote *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DeltaVolQuoteHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< DeltaVolQuote > *arg1 = 0 ;
  ext::shared_ptr< DeltaVolQuote > tempnull1 ;
  Handle< DeltaVolQuote > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< DeltaVolQuote > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Handle< DeltaVolQuote > *)new Handle< DeltaVolQuote >((ext::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 ;
  ext::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 = result ? new ext::shared_ptr< DeltaVolQuote >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DeltaVolQuoteHandle_currentLink(void * jarg1) {
  void * jresult ;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  ext::shared_ptr< DeltaVolQuote > result;
  
  arg1 = (Handle< DeltaVolQuote > *)jarg1; 
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< DeltaVolQuote >(result) : 0; 
  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 ;
  ext::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 = result ? new ext::shared_ptr< Observable >(result) : 0; 
  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_delta(void * jarg1) {
  double jresult ;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  Real result;
  
  arg1 = (Handle< DeltaVolQuote > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->delta();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DeltaVolQuoteHandle_maturity(void * jarg1) {
  double jresult ;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  Time result;
  
  arg1 = (Handle< DeltaVolQuote > *)jarg1; 
  {
    try {
      result = (Time)(*arg1)->maturity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_DeltaVolQuoteHandle_atmType(void * jarg1) {
  int jresult ;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  DeltaVolQuote::AtmType result;
  
  arg1 = (Handle< DeltaVolQuote > *)jarg1; 
  {
    try {
      result = (DeltaVolQuote::AtmType)(*arg1)->atmType();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_DeltaVolQuoteHandle_deltaType(void * jarg1) {
  int jresult ;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  DeltaVolQuote::DeltaType result;
  
  arg1 = (Handle< DeltaVolQuote > *)jarg1; 
  {
    try {
      result = (DeltaVolQuote::DeltaType)(*arg1)->deltaType();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_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 unsigned int SWIGSTDCALL CSharp_QuantLib_DeltaVolQuoteHandle_isValid(void * jarg1) {
  unsigned int jresult ;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  bool result;
  
  arg1 = (Handle< DeltaVolQuote > *)jarg1; 
  {
    try {
      result = (bool)(*arg1)->isValid();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  ext::shared_ptr< DeltaVolQuote > *arg1 = 0 ;
  ext::shared_ptr< DeltaVolQuote > tempnull1 ;
  RelinkableHandle< DeltaVolQuote > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< DeltaVolQuote > *)jarg1 : &tempnull1; 
  {
    try {
      result = (RelinkableHandle< DeltaVolQuote > *)new RelinkableHandle< DeltaVolQuote >((ext::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 ;
  ext::shared_ptr< DeltaVolQuote > *arg2 = 0 ;
  ext::shared_ptr< DeltaVolQuote > tempnull2 ;
  
  arg1 = (RelinkableHandle< DeltaVolQuote > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< DeltaVolQuote > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->linkTo((ext::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_RelinkableDeltaVolQuoteHandle_reset(void * jarg1) {
  RelinkableHandle< DeltaVolQuote > *arg1 = (RelinkableHandle< DeltaVolQuote > *) 0 ;
  
  arg1 = (RelinkableHandle< DeltaVolQuote > *)jarg1; 
  {
    try {
      RelinkableHandle_Sl_DeltaVolQuote_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 double SWIGSTDCALL CSharp_QuantLib_OneAssetOption_delta(void * jarg1) {
  double jresult ;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OneAssetOption > *)jarg1;
  arg1 = (OneAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->delta();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OneAssetOption_deltaForward(void * jarg1) {
  double jresult ;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OneAssetOption > *)jarg1;
  arg1 = (OneAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((OneAssetOption 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_OneAssetOption_elasticity(void * jarg1) {
  double jresult ;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OneAssetOption > *)jarg1;
  arg1 = (OneAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->elasticity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OneAssetOption_gamma(void * jarg1) {
  double jresult ;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OneAssetOption > *)jarg1;
  arg1 = (OneAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->gamma();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OneAssetOption_theta(void * jarg1) {
  double jresult ;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OneAssetOption > *)jarg1;
  arg1 = (OneAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->theta();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OneAssetOption_thetaPerDay(void * jarg1) {
  double jresult ;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OneAssetOption > *)jarg1;
  arg1 = (OneAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->thetaPerDay();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OneAssetOption_vega(void * jarg1) {
  double jresult ;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OneAssetOption > *)jarg1;
  arg1 = (OneAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->vega();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OneAssetOption_rho(void * jarg1) {
  double jresult ;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OneAssetOption > *)jarg1;
  arg1 = (OneAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OneAssetOption_dividendRho(void * jarg1) {
  double jresult ;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OneAssetOption > *)jarg1;
  arg1 = (OneAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->dividendRho();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OneAssetOption_strikeSensitivity(void * jarg1) {
  double jresult ;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OneAssetOption > *)jarg1;
  arg1 = (OneAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((OneAssetOption 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_OneAssetOption_itmCashProbability(void * jarg1) {
  double jresult ;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OneAssetOption > *)jarg1;
  arg1 = (OneAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((OneAssetOption 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 void SWIGSTDCALL CSharp_QuantLib_delete_OneAssetOption(void * jarg1) {
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  ext::shared_ptr< OneAssetOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OneAssetOption > *)jarg1;
  arg1 = (OneAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VanillaOption(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< StrikedTypePayoff > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  VanillaOption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  {
    try {
      result = (VanillaOption *)new VanillaOption((ext::shared_ptr< StrikedTypePayoff > const &)*arg1,(ext::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 = result ? new ext::shared_ptr<  VanillaOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  Volatility arg7 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaOption > *)jarg1;
  arg1 = (VanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Volatility)jarg6; 
  arg7 = (Volatility)jarg7; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaOption > *)jarg1;
  arg1 = (VanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Volatility)jarg6; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaOption > *)jarg1;
  arg1 = (VanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaOption > *)jarg1;
  arg1 = (VanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaOption > *)jarg1;
  arg1 = (VanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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_impliedVolatility__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, unsigned long jarg6, double jarg7, double jarg8) {
  double jresult ;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaOption > *)jarg1;
  arg1 = (VanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (DividendSchedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DividendSchedule const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Volatility)jarg7; 
  arg8 = (Volatility)jarg8; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule 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_VanillaOption_impliedVolatility__SWIG_6(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, unsigned long jarg6, double jarg7) {
  double jresult ;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  Volatility arg7 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaOption > *)jarg1;
  arg1 = (VanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (DividendSchedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DividendSchedule const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Volatility)jarg7; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule 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_VanillaOption_impliedVolatility__SWIG_7(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, unsigned long jarg6) {
  double jresult ;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaOption > *)jarg1;
  arg1 = (VanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (DividendSchedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DividendSchedule const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule 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_VanillaOption_impliedVolatility__SWIG_8(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5) {
  double jresult ;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  Real arg5 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaOption > *)jarg1;
  arg1 = (VanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (DividendSchedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DividendSchedule const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule 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_VanillaOption_impliedVolatility__SWIG_9(void * jarg1, double jarg2, void * jarg3, void * jarg4) {
  double jresult ;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaOption > *)jarg1;
  arg1 = (VanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (DividendSchedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DividendSchedule const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule 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_VanillaOption_priceCurve(void * jarg1) {
  void * jresult ;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  SampledCurve result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaOption > *)jarg1;
  arg1 = (VanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = VanillaOption_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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_VanillaOption(void * jarg1) {
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaOption > *)jarg1;
  arg1 = (VanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CalibrationPair__SWIG_0() {
  void * jresult ;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *result = 0 ;
  
  {
    try {
      result = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)new std::pair< ext::shared_ptr< VanillaOption >,ext::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_CalibrationPair__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< VanillaOption > arg1 ;
  ext::shared_ptr< Quote > arg2 ;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< VanillaOption > *)jarg1; 
  if (jarg2) arg2 = *(ext::shared_ptr< Quote > *)jarg2; 
  {
    try {
      result = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)new std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >(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_CalibrationPair__SWIG_2(void * jarg1) {
  void * jresult ;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *arg1 = 0 ;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *result = 0 ;
  
  arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)new std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >((std::pair< ext::shared_ptr< VanillaOption >,ext::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_CalibrationPair_first_set(void * jarg1, void * jarg2) {
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *) 0 ;
  ext::shared_ptr< VanillaOption > *arg2 = 0 ;
  ext::shared_ptr< VanillaOption > tempnull2 ;
  
  arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< VanillaOption > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->first = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibrationPair_first_get(void * jarg1) {
  void * jresult ;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *) 0 ;
  ext::shared_ptr< VanillaOption > *result = 0 ;
  
  arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)jarg1; 
  result = (ext::shared_ptr< VanillaOption > *) & ((arg1)->first);
  jresult = *result ? new ext::shared_ptr< VanillaOption >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CalibrationPair_second_set(void * jarg1, void * jarg2) {
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *) 0 ;
  ext::shared_ptr< Quote > *arg2 = 0 ;
  ext::shared_ptr< Quote > tempnull2 ;
  
  arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Quote > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->second = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibrationPair_second_get(void * jarg1) {
  void * jresult ;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *) 0 ;
  ext::shared_ptr< Quote > *result = 0 ;
  
  arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)jarg1; 
  result = (ext::shared_ptr< Quote > *) & ((arg1)->second);
  jresult = *result ? new ext::shared_ptr< Quote >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CalibrationPair(void * jarg1) {
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *) 0 ;
  
  arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::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_CalibrationSet_Clear(void * jarg1) {
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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_CalibrationSet_Add(void * jarg1, void * jarg2) {
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::pair< ext::shared_ptr< VanillaOption >,ext::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_CalibrationSet_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type result;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1; 
  {
    try {
      result = ((std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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_CalibrationSet_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type result;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1; 
  {
    try {
      result = ((std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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_CalibrationSet_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type arg2 ;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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_CalibrationSet__SWIG_0() {
  void * jresult ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *result = 0 ;
  
  {
    try {
      result = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)new std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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_CalibrationSet__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *result = 0 ;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)new std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >((std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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_CalibrationSet__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)new_std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_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_CalibrationSet_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > result;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_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::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CalibrationSet_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type *result = 0 ;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type *) &std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_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_CalibrationSet_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__setitem(arg1,arg2,(std::pair< ext::shared_ptr< VanillaOption >,ext::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_CalibrationSet_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__AddRange(arg1,(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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_CalibrationSet_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *result = 0 ;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_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_CalibrationSet_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__Insert(arg1,arg2,(std::pair< ext::shared_ptr< VanillaOption >,ext::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_CalibrationSet_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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_CalibrationSet_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_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_CalibrationSet_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_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_CalibrationSet_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *arg1 = 0 ;
  int arg2 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *result = 0 ;
  
  arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > const & is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__Repeat((std::pair< ext::shared_ptr< VanillaOption >,ext::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_CalibrationSet_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1; 
  {
    try {
      std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_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_CalibrationSet_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_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_CalibrationSet_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__SetRange(arg1,arg2,(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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_CalibrationSet(void * jarg1) {
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  
  arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::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_new_EuropeanOption(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< StrikedTypePayoff > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  EuropeanOption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  {
    try {
      result = (EuropeanOption *)new EuropeanOption((ext::shared_ptr< StrikedTypePayoff > const &)*arg1,(ext::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 = result ? new ext::shared_ptr<  EuropeanOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EuropeanOption(void * jarg1) {
  EuropeanOption *arg1 = (EuropeanOption *) 0 ;
  ext::shared_ptr< EuropeanOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EuropeanOption > *)jarg1;
  arg1 = (EuropeanOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< StrikedTypePayoff > *arg3 = 0 ;
  ext::shared_ptr< Exercise > *arg4 = 0 ;
  Date *argp2 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull3 ;
  ext::shared_ptr< Exercise > tempnull4 ;
  ForwardVanillaOption *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 = jarg3 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< Exercise > *)jarg4 : &tempnull4; 
  {
    try {
      result = (ForwardVanillaOption *)new ForwardVanillaOption(arg1,arg2,(ext::shared_ptr< StrikedTypePayoff > const &)*arg3,(ext::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 = result ? new ext::shared_ptr<  ForwardVanillaOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ForwardVanillaOption(void * jarg1) {
  ForwardVanillaOption *arg1 = (ForwardVanillaOption *) 0 ;
  ext::shared_ptr< ForwardVanillaOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ForwardVanillaOption > *)jarg1;
  arg1 = (ForwardVanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< StrikedTypePayoff > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  QuantoVanillaOption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  {
    try {
      result = (QuantoVanillaOption *)new QuantoVanillaOption((ext::shared_ptr< StrikedTypePayoff > const &)*arg1,(ext::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 = result ? new ext::shared_ptr<  QuantoVanillaOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_QuantoVanillaOption_qvega(void * jarg1) {
  double jresult ;
  QuantoVanillaOption *arg1 = (QuantoVanillaOption *) 0 ;
  ext::shared_ptr< QuantoVanillaOption > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  QuantoVanillaOption > *)jarg1;
  arg1 = (QuantoVanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->qvega();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  QuantoVanillaOption *arg1 = (QuantoVanillaOption *) 0 ;
  ext::shared_ptr< QuantoVanillaOption > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  QuantoVanillaOption > *)jarg1;
  arg1 = (QuantoVanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->qrho();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  QuantoVanillaOption *arg1 = (QuantoVanillaOption *) 0 ;
  ext::shared_ptr< QuantoVanillaOption > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  QuantoVanillaOption > *)jarg1;
  arg1 = (QuantoVanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->qlambda();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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) {
  QuantoVanillaOption *arg1 = (QuantoVanillaOption *) 0 ;
  ext::shared_ptr< QuantoVanillaOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  QuantoVanillaOption > *)jarg1;
  arg1 = (QuantoVanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< StrikedTypePayoff > *arg3 = 0 ;
  ext::shared_ptr< Exercise > *arg4 = 0 ;
  Date *argp2 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull3 ;
  ext::shared_ptr< Exercise > tempnull4 ;
  QuantoForwardVanillaOption *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 = jarg3 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< Exercise > *)jarg4 : &tempnull4; 
  {
    try {
      result = (QuantoForwardVanillaOption *)new QuantoForwardVanillaOption(arg1,arg2,(ext::shared_ptr< StrikedTypePayoff > const &)*arg3,(ext::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 = result ? new ext::shared_ptr<  QuantoForwardVanillaOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QuantoForwardVanillaOption(void * jarg1) {
  QuantoForwardVanillaOption *arg1 = (QuantoForwardVanillaOption *) 0 ;
  ext::shared_ptr< QuantoForwardVanillaOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  QuantoForwardVanillaOption > *)jarg1;
  arg1 = (QuantoForwardVanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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 ;
  MultiAssetOption *arg1 = (MultiAssetOption *) 0 ;
  ext::shared_ptr< MultiAssetOption > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  MultiAssetOption > *)jarg1;
  arg1 = (MultiAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->delta();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  MultiAssetOption *arg1 = (MultiAssetOption *) 0 ;
  ext::shared_ptr< MultiAssetOption > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  MultiAssetOption > *)jarg1;
  arg1 = (MultiAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->gamma();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  MultiAssetOption *arg1 = (MultiAssetOption *) 0 ;
  ext::shared_ptr< MultiAssetOption > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  MultiAssetOption > *)jarg1;
  arg1 = (MultiAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->theta();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  MultiAssetOption *arg1 = (MultiAssetOption *) 0 ;
  ext::shared_ptr< MultiAssetOption > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  MultiAssetOption > *)jarg1;
  arg1 = (MultiAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->vega();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  MultiAssetOption *arg1 = (MultiAssetOption *) 0 ;
  ext::shared_ptr< MultiAssetOption > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  MultiAssetOption > *)jarg1;
  arg1 = (MultiAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->rho();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  MultiAssetOption *arg1 = (MultiAssetOption *) 0 ;
  ext::shared_ptr< MultiAssetOption > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  MultiAssetOption > *)jarg1;
  arg1 = (MultiAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->dividendRho();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_MultiAssetOption(void * jarg1) {
  MultiAssetOption *arg1 = (MultiAssetOption *) 0 ;
  ext::shared_ptr< MultiAssetOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MultiAssetOption > *)jarg1;
  arg1 = (MultiAssetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticEuropeanEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticEuropeanEngine *)new AnalyticEuropeanEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticEuropeanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticEuropeanEngine__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticEuropeanEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticEuropeanEngine *)new AnalyticEuropeanEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  AnalyticEuropeanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticEuropeanEngine(void * jarg1) {
  AnalyticEuropeanEngine *arg1 = (AnalyticEuropeanEngine *) 0 ;
  ext::shared_ptr< AnalyticEuropeanEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticEuropeanEngine > *)jarg1;
  arg1 = (AnalyticEuropeanEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  HestonModel *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (HestonModel *)new HestonModel((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  HestonModel >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HestonModel_theta(void * jarg1) {
  double jresult ;
  HestonModel *arg1 = (HestonModel *) 0 ;
  ext::shared_ptr< HestonModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const HestonModel > *)jarg1;
  arg1 = (HestonModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((HestonModel const *)arg1)->theta();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  HestonModel *arg1 = (HestonModel *) 0 ;
  ext::shared_ptr< HestonModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const HestonModel > *)jarg1;
  arg1 = (HestonModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((HestonModel const *)arg1)->kappa();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  HestonModel *arg1 = (HestonModel *) 0 ;
  ext::shared_ptr< HestonModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const HestonModel > *)jarg1;
  arg1 = (HestonModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((HestonModel const *)arg1)->sigma();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  HestonModel *arg1 = (HestonModel *) 0 ;
  ext::shared_ptr< HestonModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const HestonModel > *)jarg1;
  arg1 = (HestonModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((HestonModel const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  HestonModel *arg1 = (HestonModel *) 0 ;
  ext::shared_ptr< HestonModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const HestonModel > *)jarg1;
  arg1 = (HestonModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((HestonModel const *)arg1)->v0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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) {
  HestonModel *arg1 = (HestonModel *) 0 ;
  ext::shared_ptr< HestonModel > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  HestonModel > *)jarg1;
  arg1 = (HestonModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HestonModelHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  Handle< HestonModel > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Handle< HestonModel > *)new Handle< HestonModel >((ext::shared_ptr< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HestonModelHandle___deref__(void * jarg1) {
  void * jresult ;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  ext::shared_ptr< HestonModel > result;
  
  arg1 = (Handle< HestonModel > *)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 = result ? new ext::shared_ptr< HestonModel >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HestonModelHandle_currentLink(void * jarg1) {
  void * jresult ;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  ext::shared_ptr< HestonModel > result;
  
  arg1 = (Handle< HestonModel > *)jarg1; 
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< HestonModel >(result) : 0; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_HestonModelHandle_empty(void * jarg1) {
  unsigned int jresult ;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  bool result;
  
  arg1 = (Handle< HestonModel > *)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_HestonModelHandle_asObservable(void * jarg1) {
  void * jresult ;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  ext::shared_ptr< Observable > result;
  
  arg1 = (Handle< HestonModel > *)jarg1; 
  {
    try {
      result = Handle_Sl_HestonModel_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 = result ? new ext::shared_ptr< Observable >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HestonModelHandle(void * jarg1) {
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  
  arg1 = (Handle< HestonModel > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_HestonModelHandle_theta(void * jarg1) {
  double jresult ;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  Real result;
  
  arg1 = (Handle< HestonModel > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->theta();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HestonModelHandle_kappa(void * jarg1) {
  double jresult ;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  Real result;
  
  arg1 = (Handle< HestonModel > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->kappa();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HestonModelHandle_sigma(void * jarg1) {
  double jresult ;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  Real result;
  
  arg1 = (Handle< HestonModel > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->sigma();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HestonModelHandle_rho(void * jarg1) {
  double jresult ;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  Real result;
  
  arg1 = (Handle< HestonModel > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->rho();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_HestonModelHandle_v0(void * jarg1) {
  double jresult ;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  Real result;
  
  arg1 = (Handle< HestonModel > *)jarg1; 
  {
    try {
      result = (Real)(*arg1)->v0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HestonModelHandle_parameters(void * jarg1) {
  void * jresult ;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  Array result;
  
  arg1 = (Handle< HestonModel > *)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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_HestonModelHandle_calibrate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  std::vector< ext::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< HestonModel > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return ;
  } 
  arg7 = (std::vector< bool > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< ext::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_HestonModelHandle_calibrate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  
  arg1 = (Handle< HestonModel > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< ext::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_HestonModelHandle_calibrate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  
  arg1 = (Handle< HestonModel > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< ext::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_HestonModelHandle_calibrate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  
  arg1 = (Handle< HestonModel > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< ext::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_HestonModelHandle_setParams(void * jarg1, void * jarg2) {
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  Array *arg2 = 0 ;
  
  arg1 = (Handle< HestonModel > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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_HestonModelHandle_value(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  Array *arg2 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg3 = 0 ;
  Real result;
  
  arg1 = (Handle< HestonModel > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->value((Array const &)*arg2,(std::vector< ext::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_HestonModelHandle_constraint(void * jarg1) {
  void * jresult ;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  ext::shared_ptr< Constraint > *result = 0 ;
  
  arg1 = (Handle< HestonModel > *)jarg1; 
  {
    try {
      result = (ext::shared_ptr< Constraint > *) &(*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 = *result ? new ext::shared_ptr< Constraint >(*result) : 0; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_HestonModelHandle_endCriteria(void * jarg1) {
  int jresult ;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  EndCriteria::Type result;
  
  arg1 = (Handle< HestonModel > *)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_HestonModelHandle_problemValues(void * jarg1) {
  void * jresult ;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  Array *result = 0 ;
  
  arg1 = (Handle< HestonModel > *)jarg1; 
  {
    try {
      result = (Array *) &(*arg1)->problemValues();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_HestonModelHandle_functionEvaluation(void * jarg1) {
  int jresult ;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  Integer result;
  
  arg1 = (Handle< HestonModel > *)jarg1; 
  {
    try {
      result = (Integer)(*arg1)->functionEvaluation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_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 ;
  PiecewiseTimeDependentHestonModel *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Parameter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Parameter const & is null", 0);
    return 0;
  } 
  arg6 = (Parameter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Parameter const & is null", 0);
    return 0;
  } 
  arg7 = (Parameter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Parameter const & is null", 0);
    return 0;
  } 
  arg8 = (Parameter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Parameter const & is null", 0);
    return 0;
  } 
  arg9 = (TimeGrid *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseTimeDependentHestonModel *)new PiecewiseTimeDependentHestonModel((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 = result ? new ext::shared_ptr<  PiecewiseTimeDependentHestonModel >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_PiecewiseTimeDependentHestonModel_theta(void * jarg1, double jarg2) {
  double jresult ;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  Time arg2 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseTimeDependentHestonModel > *)jarg1;
  arg1 = (PiecewiseTimeDependentHestonModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)((PiecewiseTimeDependentHestonModel const *)arg1)->theta(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  Time arg2 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseTimeDependentHestonModel > *)jarg1;
  arg1 = (PiecewiseTimeDependentHestonModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)((PiecewiseTimeDependentHestonModel const *)arg1)->kappa(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  Time arg2 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseTimeDependentHestonModel > *)jarg1;
  arg1 = (PiecewiseTimeDependentHestonModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)((PiecewiseTimeDependentHestonModel const *)arg1)->sigma(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  Time arg2 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseTimeDependentHestonModel > *)jarg1;
  arg1 = (PiecewiseTimeDependentHestonModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)((PiecewiseTimeDependentHestonModel 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_PiecewiseTimeDependentHestonModel_v0(void * jarg1) {
  double jresult ;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseTimeDependentHestonModel > *)jarg1;
  arg1 = (PiecewiseTimeDependentHestonModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((PiecewiseTimeDependentHestonModel const *)arg1)->v0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseTimeDependentHestonModel > *)jarg1;
  arg1 = (PiecewiseTimeDependentHestonModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((PiecewiseTimeDependentHestonModel const *)arg1)->s0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  TimeGrid *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseTimeDependentHestonModel > *)jarg1;
  arg1 = (PiecewiseTimeDependentHestonModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (TimeGrid *) &((PiecewiseTimeDependentHestonModel const *)arg1)->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_PiecewiseTimeDependentHestonModel_dividendYield(void * jarg1) {
  void * jresult ;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  Handle< YieldTermStructure > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseTimeDependentHestonModel > *)jarg1;
  arg1 = (PiecewiseTimeDependentHestonModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Handle< YieldTermStructure > *) &((PiecewiseTimeDependentHestonModel const *)arg1)->dividendYield();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  Handle< YieldTermStructure > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseTimeDependentHestonModel > *)jarg1;
  arg1 = (PiecewiseTimeDependentHestonModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Handle< YieldTermStructure > *) &((PiecewiseTimeDependentHestonModel const *)arg1)->riskFreeRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(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) {
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseTimeDependentHestonModel > *)jarg1;
  arg1 = (PiecewiseTimeDependentHestonModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_gaussLaguerre__SWIG_0(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussLaguerre(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new AnalyticHestonEngine::Integration(result); 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_gaussLegendre__SWIG_0(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussLegendre(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new AnalyticHestonEngine::Integration(result); 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_gaussChebyshev__SWIG_0(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussChebyshev(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new AnalyticHestonEngine::Integration(result); 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_gaussChebyshev2nd__SWIG_0(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussChebyshev2nd(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new AnalyticHestonEngine::Integration(result); 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_gaussLobatto__SWIG_0(double jarg1, double jarg2, unsigned long jarg3, unsigned int jarg4) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  bool arg4 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussLobatto(arg1,arg2,SWIG_STD_MOVE(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 AnalyticHestonEngine::Integration(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_gaussLobatto__SWIG_1(double jarg1, double jarg2, unsigned long jarg3) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussLobatto(arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new AnalyticHestonEngine::Integration(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_gaussLobatto__SWIG_2(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussLobatto(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 AnalyticHestonEngine::Integration(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_gaussKronrod__SWIG_0(double jarg1, unsigned long jarg2) {
  void * jresult ;
  Real arg1 ;
  Size arg2 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  arg1 = (Real)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussKronrod(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new AnalyticHestonEngine::Integration(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_gaussKronrod__SWIG_1(double jarg1) {
  void * jresult ;
  Real arg1 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussKronrod(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new AnalyticHestonEngine::Integration(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_simpson__SWIG_0(double jarg1, unsigned long jarg2) {
  void * jresult ;
  Real arg1 ;
  Size arg2 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  arg1 = (Real)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = AnalyticHestonEngine::Integration::simpson(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new AnalyticHestonEngine::Integration(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_simpson__SWIG_1(double jarg1) {
  void * jresult ;
  Real arg1 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = AnalyticHestonEngine::Integration::simpson(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new AnalyticHestonEngine::Integration(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_trapezoid__SWIG_0(double jarg1, unsigned long jarg2) {
  void * jresult ;
  Real arg1 ;
  Size arg2 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  arg1 = (Real)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = AnalyticHestonEngine::Integration::trapezoid(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new AnalyticHestonEngine::Integration(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_trapezoid__SWIG_1(double jarg1) {
  void * jresult ;
  Real arg1 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = AnalyticHestonEngine::Integration::trapezoid(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new AnalyticHestonEngine::Integration(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_discreteSimpson__SWIG_0(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = AnalyticHestonEngine::Integration::discreteSimpson(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new AnalyticHestonEngine::Integration(result); 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_discreteTrapezoid__SWIG_0(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = AnalyticHestonEngine::Integration::discreteTrapezoid(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new AnalyticHestonEngine::Integration(result); 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_expSinh__SWIG_0(double jarg1) {
  void * jresult ;
  Real arg1 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = AnalyticHestonEngine::Integration::expSinh(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new AnalyticHestonEngine::Integration(result); 
  return jresult;
}


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


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_andersenPiterbargIntegrationLimit(double jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)AnalyticHestonEngine::Integration::andersenPiterbargIntegrationLimit(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 unsigned long SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_Integration_numberOfEvaluations(void * jarg1) {
  unsigned long jresult ;
  AnalyticHestonEngine::Integration *arg1 = (AnalyticHestonEngine::Integration *) 0 ;
  Size result;
  
  arg1 = (AnalyticHestonEngine::Integration *)jarg1; 
  {
    try {
      result = ((AnalyticHestonEngine::Integration const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_AnalyticHestonEngine_AnalyticHestonEngine_Integration_isAdaptiveIntegration(void * jarg1) {
  unsigned int jresult ;
  AnalyticHestonEngine::Integration *arg1 = (AnalyticHestonEngine::Integration *) 0 ;
  bool result;
  
  arg1 = (AnalyticHestonEngine::Integration *)jarg1; 
  {
    try {
      result = (bool)((AnalyticHestonEngine::Integration const *)arg1)->isAdaptiveIntegration();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_AnalyticHestonEngine_AnalyticHestonEngine_Integration(void * jarg1) {
  AnalyticHestonEngine::Integration *arg1 = (AnalyticHestonEngine::Integration *) 0 ;
  
  arg1 = (AnalyticHestonEngine::Integration *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_AnalyticHestonEngine_OptimalAlpha(double jarg1, void * jarg2) {
  void * jresult ;
  Time arg1 ;
  ext::shared_ptr< AnalyticHestonEngine > *arg2 = 0 ;
  ext::shared_ptr< AnalyticHestonEngine > tempnull2 ;
  AnalyticHestonEngine::OptimalAlpha *result = 0 ;
  
  arg1 = (Time)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< AnalyticHestonEngine > *)jarg2 : &tempnull2; 
  {
    try {
      result = (AnalyticHestonEngine::OptimalAlpha *)new_AnalyticHestonEngine_OptimalAlpha(arg1,(ext::shared_ptr< AnalyticHestonEngine > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_AnalyticHestonEngine_AnalyticHestonEngine_OptimalAlpha_call(void * jarg1, double jarg2) {
  double jresult ;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (AnalyticHestonEngine::OptimalAlpha *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((AnalyticHestonEngine::OptimalAlpha 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_AnalyticHestonEngine_AnalyticHestonEngine_OptimalAlpha_alphaGreaterZero(void * jarg1, double jarg2) {
  void * jresult ;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  Real arg2 ;
  std::pair< Real,Real > result;
  
  arg1 = (AnalyticHestonEngine::OptimalAlpha *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = ((AnalyticHestonEngine::OptimalAlpha const *)arg1)->alphaGreaterZero(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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< Real,Real >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_OptimalAlpha_alphaSmallerMinusOne(void * jarg1, double jarg2) {
  void * jresult ;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  Real arg2 ;
  std::pair< Real,Real > result;
  
  arg1 = (AnalyticHestonEngine::OptimalAlpha *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = ((AnalyticHestonEngine::OptimalAlpha const *)arg1)->alphaSmallerMinusOne(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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< Real,Real >(result); 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_OptimalAlpha_numberOfEvaluations(void * jarg1) {
  unsigned long jresult ;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  Size result;
  
  arg1 = (AnalyticHestonEngine::OptimalAlpha *)jarg1; 
  {
    try {
      result = ((AnalyticHestonEngine::OptimalAlpha const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_AnalyticHestonEngine_AnalyticHestonEngine_OptimalAlpha_M(void * jarg1, double jarg2) {
  double jresult ;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (AnalyticHestonEngine::OptimalAlpha *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((AnalyticHestonEngine::OptimalAlpha const *)arg1)->M(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_OptimalAlpha_k(void * jarg1, double jarg2, int jarg3) {
  double jresult ;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  Real arg2 ;
  Integer arg3 ;
  Real result;
  
  arg1 = (AnalyticHestonEngine::OptimalAlpha *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Integer)jarg3; 
  {
    try {
      result = (Real)((AnalyticHestonEngine::OptimalAlpha const *)arg1)->k(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_AnalyticHestonEngine_AnalyticHestonEngine_OptimalAlpha_alphaMin(void * jarg1, double jarg2) {
  double jresult ;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (AnalyticHestonEngine::OptimalAlpha *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((AnalyticHestonEngine::OptimalAlpha const *)arg1)->alphaMin(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_AnalyticHestonEngine_OptimalAlpha_alphaMax(void * jarg1, double jarg2) {
  double jresult ;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  Real arg2 ;
  Real result;
  
  arg1 = (AnalyticHestonEngine::OptimalAlpha *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((AnalyticHestonEngine::OptimalAlpha const *)arg1)->alphaMax(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_AnalyticHestonEngine_AnalyticHestonEngine_OptimalAlpha(void * jarg1) {
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  
  arg1 = (AnalyticHestonEngine::OptimalAlpha *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  AnalyticHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (AnalyticHestonEngine *)new AnalyticHestonEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  AnalyticHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticHestonEngine__SWIG_1(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  AnalyticHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticHestonEngine *)new AnalyticHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticHestonEngine__SWIG_2(void * jarg1, double jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  AnalyticHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (AnalyticHestonEngine *)new AnalyticHestonEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  AnalyticHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticHestonEngine__SWIG_3(void * jarg1, int jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  AnalyticHestonEngine::ComplexLogFormula arg2 ;
  AnalyticHestonEngine::Integration *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  AnalyticHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (AnalyticHestonEngine::ComplexLogFormula)jarg2; 
  arg3 = (AnalyticHestonEngine::Integration *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "AnalyticHestonEngine::Integration const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (AnalyticHestonEngine *)new AnalyticHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(AnalyticHestonEngine::Integration 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 ? new ext::shared_ptr<  AnalyticHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticHestonEngine__SWIG_4(void * jarg1, int jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  AnalyticHestonEngine::ComplexLogFormula arg2 ;
  AnalyticHestonEngine::Integration *arg3 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  AnalyticHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (AnalyticHestonEngine::ComplexLogFormula)jarg2; 
  arg3 = (AnalyticHestonEngine::Integration *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "AnalyticHestonEngine::Integration const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticHestonEngine *)new AnalyticHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(AnalyticHestonEngine::Integration 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 ? new ext::shared_ptr<  AnalyticHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_numberOfEvaluations(void * jarg1) {
  unsigned long jresult ;
  AnalyticHestonEngine *arg1 = (AnalyticHestonEngine *) 0 ;
  ext::shared_ptr< AnalyticHestonEngine const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const AnalyticHestonEngine > *)jarg1;
  arg1 = (AnalyticHestonEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((AnalyticHestonEngine const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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 SwigSystemNumericsComplex SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_chF(void * jarg1, SwigSystemNumericsComplex jarg2, double jarg3) {
  SwigSystemNumericsComplex jresult ;
  AnalyticHestonEngine *arg1 = (AnalyticHestonEngine *) 0 ;
  std::complex< Real > *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< AnalyticHestonEngine const > *smartarg1 = 0 ;
  std::complex< Real > temp2 ;
  std::complex< Real > result;
  
  
  smartarg1 = (ext::shared_ptr< const AnalyticHestonEngine > *)jarg1;
  arg1 = (AnalyticHestonEngine *)(smartarg1 ? smartarg1->get() : 0); 
  temp2 = std::complex< double >((double)jarg2.real, (double)jarg2.imag);
  arg2 = &temp2;
  arg3 = (Time)jarg3; 
  {
    try {
      result = ((AnalyticHestonEngine const *)arg1)->chF((std::complex< Real > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return SwigCreateSystemNumericsComplex(0.0, 0.0); 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return SwigCreateSystemNumericsComplex(0.0, 0.0); 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return SwigCreateSystemNumericsComplex(0.0, 0.0); 
      };
    }
  }
  jresult = SwigCreateSystemNumericsComplex((&result)->real(), (&result)->imag());
  return jresult;
}


SWIGEXPORT SwigSystemNumericsComplex SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_lnChF(void * jarg1, SwigSystemNumericsComplex jarg2, double jarg3) {
  SwigSystemNumericsComplex jresult ;
  AnalyticHestonEngine *arg1 = (AnalyticHestonEngine *) 0 ;
  std::complex< Real > *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< AnalyticHestonEngine const > *smartarg1 = 0 ;
  std::complex< Real > temp2 ;
  std::complex< Real > result;
  
  
  smartarg1 = (ext::shared_ptr< const AnalyticHestonEngine > *)jarg1;
  arg1 = (AnalyticHestonEngine *)(smartarg1 ? smartarg1->get() : 0); 
  temp2 = std::complex< double >((double)jarg2.real, (double)jarg2.imag);
  arg2 = &temp2;
  arg3 = (Time)jarg3; 
  {
    try {
      result = ((AnalyticHestonEngine const *)arg1)->lnChF((std::complex< Real > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return SwigCreateSystemNumericsComplex(0.0, 0.0); 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return SwigCreateSystemNumericsComplex(0.0, 0.0); 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return SwigCreateSystemNumericsComplex(0.0, 0.0); 
      };
    }
  }
  jresult = SwigCreateSystemNumericsComplex((&result)->real(), (&result)->imag());
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticHestonEngine(void * jarg1) {
  AnalyticHestonEngine *arg1 = (AnalyticHestonEngine *) 0 ;
  ext::shared_ptr< AnalyticHestonEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticHestonEngine > *)jarg1;
  arg1 = (AnalyticHestonEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_COSHestonEngine__SWIG_0(void * jarg1, double jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  COSHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (COSHestonEngine *)new COSHestonEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  COSHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_COSHestonEngine__SWIG_1(void * jarg1, double jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  COSHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (COSHestonEngine *)new COSHestonEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  COSHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_COSHestonEngine__SWIG_2(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  COSHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (COSHestonEngine *)new COSHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  COSHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_COSHestonEngine(void * jarg1) {
  COSHestonEngine *arg1 = (COSHestonEngine *) 0 ;
  ext::shared_ptr< COSHestonEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  COSHestonEngine > *)jarg1;
  arg1 = (COSHestonEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialFittingHestonEngine__SWIG_0(void * jarg1, int jarg2, double jarg3, double jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ExponentialFittingHestonEngine::ControlVariate arg2 ;
  doubleOrNull arg3 ;
  Real arg4 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ExponentialFittingHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (ExponentialFittingHestonEngine::ControlVariate)jarg2; 
  arg3 = (doubleOrNull)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (ExponentialFittingHestonEngine *)new ExponentialFittingHestonEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  ExponentialFittingHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialFittingHestonEngine__SWIG_1(void * jarg1, int jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ExponentialFittingHestonEngine::ControlVariate arg2 ;
  doubleOrNull arg3 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ExponentialFittingHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (ExponentialFittingHestonEngine::ControlVariate)jarg2; 
  arg3 = (doubleOrNull)jarg3; 
  {
    try {
      result = (ExponentialFittingHestonEngine *)new ExponentialFittingHestonEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  ExponentialFittingHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialFittingHestonEngine__SWIG_2(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ExponentialFittingHestonEngine::ControlVariate arg2 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ExponentialFittingHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (ExponentialFittingHestonEngine::ControlVariate)jarg2; 
  {
    try {
      result = (ExponentialFittingHestonEngine *)new ExponentialFittingHestonEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  ExponentialFittingHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialFittingHestonEngine__SWIG_3(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ExponentialFittingHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (ExponentialFittingHestonEngine *)new ExponentialFittingHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  ExponentialFittingHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ExponentialFittingHestonEngine(void * jarg1) {
  ExponentialFittingHestonEngine *arg1 = (ExponentialFittingHestonEngine *) 0 ;
  ext::shared_ptr< ExponentialFittingHestonEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ExponentialFittingHestonEngine > *)jarg1;
  arg1 = (ExponentialFittingHestonEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > tempnull1 ;
  AnalyticPTDHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< PiecewiseTimeDependentHestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (AnalyticPTDHestonEngine *)new AnalyticPTDHestonEngine((ext::shared_ptr< PiecewiseTimeDependentHestonModel > 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 ? new ext::shared_ptr<  AnalyticPTDHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticPTDHestonEngine__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > tempnull1 ;
  AnalyticPTDHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< PiecewiseTimeDependentHestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (AnalyticPTDHestonEngine *)new AnalyticPTDHestonEngine((ext::shared_ptr< PiecewiseTimeDependentHestonModel > 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 ? new ext::shared_ptr<  AnalyticPTDHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticPTDHestonEngine__SWIG_2(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > *arg1 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > tempnull1 ;
  AnalyticPTDHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< PiecewiseTimeDependentHestonModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticPTDHestonEngine *)new AnalyticPTDHestonEngine((ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticPTDHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticPTDHestonEngine__SWIG_3(void * jarg1, int jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > *arg1 = 0 ;
  AnalyticPTDHestonEngine::ComplexLogFormula arg2 ;
  AnalyticPTDHestonEngine::Integration *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > tempnull1 ;
  AnalyticPTDHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< PiecewiseTimeDependentHestonModel > *)jarg1 : &tempnull1; 
  arg2 = (AnalyticPTDHestonEngine::ComplexLogFormula)jarg2; 
  arg3 = (AnalyticPTDHestonEngine::Integration *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "AnalyticPTDHestonEngine::Integration const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (AnalyticPTDHestonEngine *)new AnalyticPTDHestonEngine((ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &)*arg1,arg2,(AnalyticPTDHestonEngine::Integration 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 ? new ext::shared_ptr<  AnalyticPTDHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticPTDHestonEngine__SWIG_4(void * jarg1, int jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > *arg1 = 0 ;
  AnalyticPTDHestonEngine::ComplexLogFormula arg2 ;
  AnalyticPTDHestonEngine::Integration *arg3 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > tempnull1 ;
  AnalyticPTDHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< PiecewiseTimeDependentHestonModel > *)jarg1 : &tempnull1; 
  arg2 = (AnalyticPTDHestonEngine::ComplexLogFormula)jarg2; 
  arg3 = (AnalyticPTDHestonEngine::Integration *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "AnalyticPTDHestonEngine::Integration const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticPTDHestonEngine *)new AnalyticPTDHestonEngine((ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &)*arg1,arg2,(AnalyticPTDHestonEngine::Integration 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 ? new ext::shared_ptr<  AnalyticPTDHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticPTDHestonEngine(void * jarg1) {
  AnalyticPTDHestonEngine *arg1 = (AnalyticPTDHestonEngine *) 0 ;
  ext::shared_ptr< AnalyticPTDHestonEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticPTDHestonEngine > *)jarg1;
  arg1 = (AnalyticPTDHestonEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< BatesProcess > *arg1 = 0 ;
  ext::shared_ptr< BatesProcess > tempnull1 ;
  BatesModel *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BatesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (BatesModel *)new BatesModel((ext::shared_ptr< BatesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  BatesModel >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BatesModel_nu(void * jarg1) {
  double jresult ;
  BatesModel *arg1 = (BatesModel *) 0 ;
  ext::shared_ptr< BatesModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BatesModel > *)jarg1;
  arg1 = (BatesModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((BatesModel const *)arg1)->nu();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  BatesModel *arg1 = (BatesModel *) 0 ;
  ext::shared_ptr< BatesModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BatesModel > *)jarg1;
  arg1 = (BatesModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((BatesModel const *)arg1)->delta();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  BatesModel *arg1 = (BatesModel *) 0 ;
  ext::shared_ptr< BatesModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BatesModel > *)jarg1;
  arg1 = (BatesModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((BatesModel const *)arg1)->lambda();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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) {
  BatesModel *arg1 = (BatesModel *) 0 ;
  ext::shared_ptr< BatesModel > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BatesModel > *)jarg1;
  arg1 = (BatesModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< BatesModel > tempnull1 ;
  BatesEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BatesModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BatesEngine *)new BatesEngine((ext::shared_ptr< BatesModel > 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 ? new ext::shared_ptr<  BatesEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BatesEngine__SWIG_1(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  ext::shared_ptr< BatesModel > tempnull1 ;
  BatesEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BatesModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (BatesEngine *)new BatesEngine((ext::shared_ptr< BatesModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  BatesEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BatesEngine__SWIG_2(void * jarg1, double jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  ext::shared_ptr< BatesModel > tempnull1 ;
  BatesEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BatesModel > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (BatesEngine *)new BatesEngine((ext::shared_ptr< BatesModel > 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 ? new ext::shared_ptr<  BatesEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BatesEngine(void * jarg1) {
  BatesEngine *arg1 = (BatesEngine *) 0 ;
  ext::shared_ptr< BatesEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BatesEngine > *)jarg1;
  arg1 = (BatesEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  IntegralEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (IntegralEngine *)new IntegralEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  IntegralEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IntegralEngine(void * jarg1) {
  IntegralEngine *arg1 = (IntegralEngine *) 0 ;
  ext::shared_ptr< IntegralEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  IntegralEngine > *)jarg1;
  arg1 = (IntegralEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialCRRVanillaEngine(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialVanillaEngine< CoxRossRubinstein > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialVanillaEngine< CoxRossRubinstein > *)new BinomialVanillaEngine< CoxRossRubinstein >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialVanillaEngine<CoxRossRubinstein> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialCRRVanillaEngine(void * jarg1) {
  BinomialVanillaEngine< CoxRossRubinstein > *arg1 = (BinomialVanillaEngine< CoxRossRubinstein > *) 0 ;
  ext::shared_ptr< BinomialVanillaEngine< CoxRossRubinstein > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialVanillaEngine<CoxRossRubinstein> > *)jarg1;
  arg1 = (BinomialVanillaEngine<CoxRossRubinstein> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialJRVanillaEngine(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialVanillaEngine< JarrowRudd > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialVanillaEngine< JarrowRudd > *)new BinomialVanillaEngine< JarrowRudd >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialVanillaEngine<JarrowRudd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialJRVanillaEngine(void * jarg1) {
  BinomialVanillaEngine< JarrowRudd > *arg1 = (BinomialVanillaEngine< JarrowRudd > *) 0 ;
  ext::shared_ptr< BinomialVanillaEngine< JarrowRudd > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialVanillaEngine<JarrowRudd> > *)jarg1;
  arg1 = (BinomialVanillaEngine<JarrowRudd> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialEQPVanillaEngine(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialVanillaEngine< AdditiveEQPBinomialTree > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialVanillaEngine< AdditiveEQPBinomialTree > *)new BinomialVanillaEngine< AdditiveEQPBinomialTree >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialVanillaEngine<AdditiveEQPBinomialTree> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialEQPVanillaEngine(void * jarg1) {
  BinomialVanillaEngine< AdditiveEQPBinomialTree > *arg1 = (BinomialVanillaEngine< AdditiveEQPBinomialTree > *) 0 ;
  ext::shared_ptr< BinomialVanillaEngine< AdditiveEQPBinomialTree > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialVanillaEngine<AdditiveEQPBinomialTree> > *)jarg1;
  arg1 = (BinomialVanillaEngine<AdditiveEQPBinomialTree> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialTrigeorgisVanillaEngine(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialVanillaEngine< Trigeorgis > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialVanillaEngine< Trigeorgis > *)new BinomialVanillaEngine< Trigeorgis >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialVanillaEngine<Trigeorgis> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialTrigeorgisVanillaEngine(void * jarg1) {
  BinomialVanillaEngine< Trigeorgis > *arg1 = (BinomialVanillaEngine< Trigeorgis > *) 0 ;
  ext::shared_ptr< BinomialVanillaEngine< Trigeorgis > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialVanillaEngine<Trigeorgis> > *)jarg1;
  arg1 = (BinomialVanillaEngine<Trigeorgis> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialTianVanillaEngine(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialVanillaEngine< Tian > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialVanillaEngine< Tian > *)new BinomialVanillaEngine< Tian >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialVanillaEngine<Tian> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialTianVanillaEngine(void * jarg1) {
  BinomialVanillaEngine< Tian > *arg1 = (BinomialVanillaEngine< Tian > *) 0 ;
  ext::shared_ptr< BinomialVanillaEngine< Tian > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialVanillaEngine<Tian> > *)jarg1;
  arg1 = (BinomialVanillaEngine<Tian> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialLRVanillaEngine(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialVanillaEngine< LeisenReimer > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialVanillaEngine< LeisenReimer > *)new BinomialVanillaEngine< LeisenReimer >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialVanillaEngine<LeisenReimer> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialLRVanillaEngine(void * jarg1) {
  BinomialVanillaEngine< LeisenReimer > *arg1 = (BinomialVanillaEngine< LeisenReimer > *) 0 ;
  ext::shared_ptr< BinomialVanillaEngine< LeisenReimer > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialVanillaEngine<LeisenReimer> > *)jarg1;
  arg1 = (BinomialVanillaEngine<LeisenReimer> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialJ4VanillaEngine(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialVanillaEngine< Joshi4 > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialVanillaEngine< Joshi4 > *)new BinomialVanillaEngine< Joshi4 >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialVanillaEngine<Joshi4> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialJ4VanillaEngine(void * jarg1) {
  BinomialVanillaEngine< Joshi4 > *arg1 = (BinomialVanillaEngine< Joshi4 > *) 0 ;
  ext::shared_ptr< BinomialVanillaEngine< Joshi4 > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialVanillaEngine<Joshi4> > *)jarg1;
  arg1 = (BinomialVanillaEngine<Joshi4> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  {
    try {
      result = (MCEuropeanEngine< PseudoRandom > *)new_MCEuropeanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCEuropeanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCEuropeanEngine< PseudoRandom > *)new_MCEuropeanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCEuropeanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCEuropeanEngine< PseudoRandom > *)new_MCEuropeanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCEuropeanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCEuropeanEngine< PseudoRandom > *)new_MCEuropeanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  MCEuropeanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCEuropeanEngine< PseudoRandom > *)new_MCEuropeanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCEuropeanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanEngine__SWIG_5(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCEuropeanEngine< PseudoRandom > *)new_MCEuropeanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCEuropeanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanEngine__SWIG_6(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCEuropeanEngine< PseudoRandom > *)new_MCEuropeanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCEuropeanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanEngine__SWIG_7(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCEuropeanEngine< PseudoRandom > *)new_MCEuropeanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCEuropeanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanEngine__SWIG_8(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCEuropeanEngine< PseudoRandom > *)new_MCEuropeanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCEuropeanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPREuropeanEngine(void * jarg1) {
  MCEuropeanEngine< PseudoRandom > *arg1 = (MCEuropeanEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCEuropeanEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCEuropeanEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCEuropeanEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  {
    try {
      result = (MCEuropeanEngine< LowDiscrepancy > *)new_MCEuropeanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCEuropeanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCEuropeanEngine< LowDiscrepancy > *)new_MCEuropeanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCEuropeanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCEuropeanEngine< LowDiscrepancy > *)new_MCEuropeanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCEuropeanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCEuropeanEngine< LowDiscrepancy > *)new_MCEuropeanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  MCEuropeanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCEuropeanEngine< LowDiscrepancy > *)new_MCEuropeanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCEuropeanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanEngine__SWIG_5(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCEuropeanEngine< LowDiscrepancy > *)new_MCEuropeanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCEuropeanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanEngine__SWIG_6(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCEuropeanEngine< LowDiscrepancy > *)new_MCEuropeanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCEuropeanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanEngine__SWIG_7(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCEuropeanEngine< LowDiscrepancy > *)new_MCEuropeanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCEuropeanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanEngine__SWIG_8(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCEuropeanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCEuropeanEngine< LowDiscrepancy > *)new_MCEuropeanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCEuropeanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDEuropeanEngine(void * jarg1) {
  MCEuropeanEngine< LowDiscrepancy > *arg1 = (MCEuropeanEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCEuropeanEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCEuropeanEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCEuropeanEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9, int jarg10, int jarg11, int jarg12, void * jarg13, unsigned long jarg14) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  intOrNull arg10 ;
  LsmBasisSystem::PolynomialType arg11 ;
  int arg12 ;
  SwigValueWrapper< ext::optional< bool > > arg13 ;
  BigNatural arg14 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::optional< bool > *argp13 ;
  MCAmericanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  arg10 = (intOrNull)jarg10; 
  arg11 = (LsmBasisSystem::PolynomialType)jarg11; 
  arg12 = (int)jarg12; 
  argp13 = (ext::optional< bool > *)jarg13; 
  if (!argp13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg13 = *argp13; 
  arg14 = (BigNatural)jarg14; 
  {
    try {
      result = (MCAmericanEngine< PseudoRandom > *)new_MCAmericanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,SWIG_STD_MOVE(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 = result ? new ext::shared_ptr<  MCAmericanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9, int jarg10, int jarg11, int jarg12, void * jarg13) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  intOrNull arg10 ;
  LsmBasisSystem::PolynomialType arg11 ;
  int arg12 ;
  SwigValueWrapper< ext::optional< bool > > arg13 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::optional< bool > *argp13 ;
  MCAmericanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  arg10 = (intOrNull)jarg10; 
  arg11 = (LsmBasisSystem::PolynomialType)jarg11; 
  arg12 = (int)jarg12; 
  argp13 = (ext::optional< bool > *)jarg13; 
  if (!argp13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg13 = *argp13; 
  {
    try {
      result = (MCAmericanEngine< PseudoRandom > *)new_MCAmericanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCAmericanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9, int jarg10, int jarg11, int jarg12) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  intOrNull arg10 ;
  LsmBasisSystem::PolynomialType arg11 ;
  int arg12 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  arg10 = (intOrNull)jarg10; 
  arg11 = (LsmBasisSystem::PolynomialType)jarg11; 
  arg12 = (int)jarg12; 
  {
    try {
      result = (MCAmericanEngine< PseudoRandom > *)new_MCAmericanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,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 ? new ext::shared_ptr<  MCAmericanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9, int jarg10, int jarg11) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  intOrNull arg10 ;
  LsmBasisSystem::PolynomialType arg11 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  arg10 = (intOrNull)jarg10; 
  arg11 = (LsmBasisSystem::PolynomialType)jarg11; 
  {
    try {
      result = (MCAmericanEngine< PseudoRandom > *)new_MCAmericanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,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 = result ? new ext::shared_ptr<  MCAmericanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9, int jarg10) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  intOrNull arg10 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  arg10 = (intOrNull)jarg10; 
  {
    try {
      result = (MCAmericanEngine< PseudoRandom > *)new_MCAmericanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,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 = result ? new ext::shared_ptr<  MCAmericanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanEngine__SWIG_5(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  {
    try {
      result = (MCAmericanEngine< PseudoRandom > *)new_MCAmericanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCAmericanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanEngine__SWIG_6(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCAmericanEngine< PseudoRandom > *)new_MCAmericanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCAmericanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanEngine__SWIG_7(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCAmericanEngine< PseudoRandom > *)new_MCAmericanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCAmericanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanEngine__SWIG_8(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCAmericanEngine< PseudoRandom > *)new_MCAmericanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  MCAmericanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanEngine__SWIG_9(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCAmericanEngine< PseudoRandom > *)new_MCAmericanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCAmericanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanEngine__SWIG_10(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCAmericanEngine< PseudoRandom > *)new_MCAmericanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCAmericanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanEngine__SWIG_11(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCAmericanEngine< PseudoRandom > *)new_MCAmericanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCAmericanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanEngine__SWIG_12(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCAmericanEngine< PseudoRandom > *)new_MCAmericanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCAmericanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanEngine__SWIG_13(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCAmericanEngine< PseudoRandom > *)new_MCAmericanEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCAmericanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPRAmericanEngine(void * jarg1) {
  MCAmericanEngine< PseudoRandom > *arg1 = (MCAmericanEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCAmericanEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCAmericanEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCAmericanEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9, int jarg10, int jarg11, int jarg12, void * jarg13, unsigned long jarg14) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  intOrNull arg10 ;
  LsmBasisSystem::PolynomialType arg11 ;
  int arg12 ;
  SwigValueWrapper< ext::optional< bool > > arg13 ;
  BigNatural arg14 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::optional< bool > *argp13 ;
  MCAmericanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  arg10 = (intOrNull)jarg10; 
  arg11 = (LsmBasisSystem::PolynomialType)jarg11; 
  arg12 = (int)jarg12; 
  argp13 = (ext::optional< bool > *)jarg13; 
  if (!argp13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg13 = *argp13; 
  arg14 = (BigNatural)jarg14; 
  {
    try {
      result = (MCAmericanEngine< LowDiscrepancy > *)new_MCAmericanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,SWIG_STD_MOVE(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 = result ? new ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9, int jarg10, int jarg11, int jarg12, void * jarg13) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  intOrNull arg10 ;
  LsmBasisSystem::PolynomialType arg11 ;
  int arg12 ;
  SwigValueWrapper< ext::optional< bool > > arg13 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::optional< bool > *argp13 ;
  MCAmericanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  arg10 = (intOrNull)jarg10; 
  arg11 = (LsmBasisSystem::PolynomialType)jarg11; 
  arg12 = (int)jarg12; 
  argp13 = (ext::optional< bool > *)jarg13; 
  if (!argp13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg13 = *argp13; 
  {
    try {
      result = (MCAmericanEngine< LowDiscrepancy > *)new_MCAmericanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9, int jarg10, int jarg11, int jarg12) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  intOrNull arg10 ;
  LsmBasisSystem::PolynomialType arg11 ;
  int arg12 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  arg10 = (intOrNull)jarg10; 
  arg11 = (LsmBasisSystem::PolynomialType)jarg11; 
  arg12 = (int)jarg12; 
  {
    try {
      result = (MCAmericanEngine< LowDiscrepancy > *)new_MCAmericanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,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 ? new ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9, int jarg10, int jarg11) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  intOrNull arg10 ;
  LsmBasisSystem::PolynomialType arg11 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  arg10 = (intOrNull)jarg10; 
  arg11 = (LsmBasisSystem::PolynomialType)jarg11; 
  {
    try {
      result = (MCAmericanEngine< LowDiscrepancy > *)new_MCAmericanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,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 = result ? new ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9, int jarg10) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  intOrNull arg10 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  arg10 = (intOrNull)jarg10; 
  {
    try {
      result = (MCAmericanEngine< LowDiscrepancy > *)new_MCAmericanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,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 = result ? new ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanEngine__SWIG_5(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  {
    try {
      result = (MCAmericanEngine< LowDiscrepancy > *)new_MCAmericanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanEngine__SWIG_6(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCAmericanEngine< LowDiscrepancy > *)new_MCAmericanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanEngine__SWIG_7(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCAmericanEngine< LowDiscrepancy > *)new_MCAmericanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanEngine__SWIG_8(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCAmericanEngine< LowDiscrepancy > *)new_MCAmericanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanEngine__SWIG_9(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCAmericanEngine< LowDiscrepancy > *)new_MCAmericanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanEngine__SWIG_10(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCAmericanEngine< LowDiscrepancy > *)new_MCAmericanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanEngine__SWIG_11(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCAmericanEngine< LowDiscrepancy > *)new_MCAmericanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanEngine__SWIG_12(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCAmericanEngine< LowDiscrepancy > *)new_MCAmericanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanEngine__SWIG_13(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCAmericanEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCAmericanEngine< LowDiscrepancy > *)new_MCAmericanEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDAmericanEngine(void * jarg1) {
  MCAmericanEngine< LowDiscrepancy > *arg1 = (MCAmericanEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCAmericanEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCAmericanEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanHestonEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7, long jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  BigInteger arg8 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (BigInteger)jarg8; 
  {
    try {
      result = (MCEuropeanHestonEngine< PseudoRandom > *)new_MCEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanHestonEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCEuropeanHestonEngine< PseudoRandom > *)new_MCEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanHestonEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  {
    try {
      result = (MCEuropeanHestonEngine< PseudoRandom > *)new_MCEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 = result ? new ext::shared_ptr<  MCEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanHestonEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  {
    try {
      result = (MCEuropeanHestonEngine< PseudoRandom > *)new_MCEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanHestonEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCEuropeanHestonEngine< PseudoRandom > *)new_MCEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanHestonEngine__SWIG_5(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCEuropeanHestonEngine< PseudoRandom > *)new_MCEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanHestonEngine__SWIG_6(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCEuropeanHestonEngine< PseudoRandom > *)new_MCEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanHestonEngine__SWIG_7(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCEuropeanHestonEngine< PseudoRandom > *)new_MCEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPREuropeanHestonEngine(void * jarg1) {
  MCEuropeanHestonEngine< PseudoRandom > *arg1 = (MCEuropeanHestonEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCEuropeanHestonEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCEuropeanHestonEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCEuropeanHestonEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanHestonEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7, long jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  BigInteger arg8 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (BigInteger)jarg8; 
  {
    try {
      result = (MCEuropeanHestonEngine< LowDiscrepancy > *)new_MCEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanHestonEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCEuropeanHestonEngine< LowDiscrepancy > *)new_MCEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanHestonEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  {
    try {
      result = (MCEuropeanHestonEngine< LowDiscrepancy > *)new_MCEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 = result ? new ext::shared_ptr<  MCEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanHestonEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  {
    try {
      result = (MCEuropeanHestonEngine< LowDiscrepancy > *)new_MCEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanHestonEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCEuropeanHestonEngine< LowDiscrepancy > *)new_MCEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanHestonEngine__SWIG_5(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCEuropeanHestonEngine< LowDiscrepancy > *)new_MCEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanHestonEngine__SWIG_6(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCEuropeanHestonEngine< LowDiscrepancy > *)new_MCEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanHestonEngine__SWIG_7(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCEuropeanHestonEngine< LowDiscrepancy > *)new_MCEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDEuropeanHestonEngine(void * jarg1) {
  MCEuropeanHestonEngine< LowDiscrepancy > *arg1 = (MCEuropeanHestonEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCEuropeanHestonEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCEuropeanHestonEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCEuropeanHestonEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDigitalEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  {
    try {
      result = (MCDigitalEngine< PseudoRandom > *)new_MCDigitalEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCDigitalEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDigitalEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCDigitalEngine< PseudoRandom > *)new_MCDigitalEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCDigitalEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDigitalEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCDigitalEngine< PseudoRandom > *)new_MCDigitalEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCDigitalEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDigitalEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCDigitalEngine< PseudoRandom > *)new_MCDigitalEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  MCDigitalEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDigitalEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCDigitalEngine< PseudoRandom > *)new_MCDigitalEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDigitalEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDigitalEngine__SWIG_5(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCDigitalEngine< PseudoRandom > *)new_MCDigitalEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDigitalEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDigitalEngine__SWIG_6(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCDigitalEngine< PseudoRandom > *)new_MCDigitalEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDigitalEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDigitalEngine__SWIG_7(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCDigitalEngine< PseudoRandom > *)new_MCDigitalEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDigitalEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDigitalEngine__SWIG_8(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCDigitalEngine< PseudoRandom > *)new_MCDigitalEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCDigitalEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPRDigitalEngine(void * jarg1) {
  MCDigitalEngine< PseudoRandom > *arg1 = (MCDigitalEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCDigitalEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCDigitalEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCDigitalEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDigitalEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  {
    try {
      result = (MCDigitalEngine< LowDiscrepancy > *)new_MCDigitalEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCDigitalEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDigitalEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCDigitalEngine< LowDiscrepancy > *)new_MCDigitalEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCDigitalEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDigitalEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCDigitalEngine< LowDiscrepancy > *)new_MCDigitalEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCDigitalEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDigitalEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCDigitalEngine< LowDiscrepancy > *)new_MCDigitalEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  MCDigitalEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDigitalEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCDigitalEngine< LowDiscrepancy > *)new_MCDigitalEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDigitalEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDigitalEngine__SWIG_5(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCDigitalEngine< LowDiscrepancy > *)new_MCDigitalEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDigitalEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDigitalEngine__SWIG_6(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCDigitalEngine< LowDiscrepancy > *)new_MCDigitalEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDigitalEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDigitalEngine__SWIG_7(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCDigitalEngine< LowDiscrepancy > *)new_MCDigitalEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDigitalEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDigitalEngine__SWIG_8(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDigitalEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCDigitalEngine< LowDiscrepancy > *)new_MCDigitalEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCDigitalEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDDigitalEngine(void * jarg1) {
  MCDigitalEngine< LowDiscrepancy > *arg1 = (MCDigitalEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCDigitalEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCDigitalEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCDigitalEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BaroneAdesiWhaleyApproximationEngine(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BaroneAdesiWhaleyApproximationEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (BaroneAdesiWhaleyApproximationEngine *)new BaroneAdesiWhaleyApproximationEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  BaroneAdesiWhaleyApproximationEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BaroneAdesiWhaleyApproximationEngine(void * jarg1) {
  BaroneAdesiWhaleyApproximationEngine *arg1 = (BaroneAdesiWhaleyApproximationEngine *) 0 ;
  ext::shared_ptr< BaroneAdesiWhaleyApproximationEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BaroneAdesiWhaleyApproximationEngine > *)jarg1;
  arg1 = (BaroneAdesiWhaleyApproximationEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BjerksundStenslandApproximationEngine(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BjerksundStenslandApproximationEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (BjerksundStenslandApproximationEngine *)new BjerksundStenslandApproximationEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  BjerksundStenslandApproximationEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BjerksundStenslandApproximationEngine(void * jarg1) {
  BjerksundStenslandApproximationEngine *arg1 = (BjerksundStenslandApproximationEngine *) 0 ;
  ext::shared_ptr< BjerksundStenslandApproximationEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BjerksundStenslandApproximationEngine > *)jarg1;
  arg1 = (BjerksundStenslandApproximationEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JuQuadraticApproximationEngine(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  JuQuadraticApproximationEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (JuQuadraticApproximationEngine *)new JuQuadraticApproximationEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  JuQuadraticApproximationEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_JuQuadraticApproximationEngine(void * jarg1) {
  JuQuadraticApproximationEngine *arg1 = (JuQuadraticApproximationEngine *) 0 ;
  ext::shared_ptr< JuQuadraticApproximationEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  JuQuadraticApproximationEngine > *)jarg1;
  arg1 = (JuQuadraticApproximationEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticDigitalAmericanEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticDigitalAmericanEngine *)new AnalyticDigitalAmericanEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticDigitalAmericanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticDigitalAmericanEngine(void * jarg1) {
  AnalyticDigitalAmericanEngine *arg1 = (AnalyticDigitalAmericanEngine *) 0 ;
  ext::shared_ptr< AnalyticDigitalAmericanEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticDigitalAmericanEngine > *)jarg1;
  arg1 = (AnalyticDigitalAmericanEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticDigitalAmericanKOEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticDigitalAmericanKOEngine *)new AnalyticDigitalAmericanKOEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticDigitalAmericanKOEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticDigitalAmericanKOEngine(void * jarg1) {
  AnalyticDigitalAmericanKOEngine *arg1 = (AnalyticDigitalAmericanKOEngine *) 0 ;
  ext::shared_ptr< AnalyticDigitalAmericanKOEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticDigitalAmericanKOEngine > *)jarg1;
  arg1 = (AnalyticDigitalAmericanKOEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< StrikedTypePayoff > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  DividendVanillaOption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DividendVanillaOption *)new DividendVanillaOption((ext::shared_ptr< StrikedTypePayoff > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2,(std::vector< Date > const &)*arg3,(std::vector< Real > 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 ? new ext::shared_ptr<  DividendVanillaOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  DividendVanillaOption *arg1 = (DividendVanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  Volatility arg7 ;
  ext::shared_ptr< DividendVanillaOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  DividendVanillaOption > *)jarg1;
  arg1 = (DividendVanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Volatility)jarg6; 
  arg7 = (Volatility)jarg7; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ;
  DividendVanillaOption *arg1 = (DividendVanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  ext::shared_ptr< DividendVanillaOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  DividendVanillaOption > *)jarg1;
  arg1 = (DividendVanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Volatility)jarg6; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ;
  DividendVanillaOption *arg1 = (DividendVanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  ext::shared_ptr< DividendVanillaOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  DividendVanillaOption > *)jarg1;
  arg1 = (DividendVanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ;
  DividendVanillaOption *arg1 = (DividendVanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< DividendVanillaOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  DividendVanillaOption > *)jarg1;
  arg1 = (DividendVanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ;
  DividendVanillaOption *arg1 = (DividendVanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  ext::shared_ptr< DividendVanillaOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  DividendVanillaOption > *)jarg1;
  arg1 = (DividendVanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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_delete_DividendVanillaOption(void * jarg1) {
  DividendVanillaOption *arg1 = (DividendVanillaOption *) 0 ;
  ext::shared_ptr< DividendVanillaOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DividendVanillaOption > *)jarg1;
  arg1 = (DividendVanillaOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticDividendEuropeanEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticDividendEuropeanEngine *)new AnalyticDividendEuropeanEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticDividendEuropeanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticDividendEuropeanEngine__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  AnalyticDividendEuropeanEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (AnalyticDividendEuropeanEngine *)new AnalyticDividendEuropeanEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  AnalyticDividendEuropeanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticDividendEuropeanEngine(void * jarg1) {
  AnalyticDividendEuropeanEngine *arg1 = (AnalyticDividendEuropeanEngine *) 0 ;
  ext::shared_ptr< AnalyticDividendEuropeanEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticDividendEuropeanEngine > *)jarg1;
  arg1 = (AnalyticDividendEuropeanEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QdPlusAmericanEngine__SWIG_0(void * jarg1, unsigned long jarg2, int jarg3, double jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  QdPlusAmericanEngine::SolverType arg3 ;
  Real arg4 ;
  Size arg5 ;
  QdPlusAmericanEngine *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (QdPlusAmericanEngine::SolverType)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (QdPlusAmericanEngine *)new QdPlusAmericanEngine(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 ? new ext::shared_ptr<  QdPlusAmericanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QdPlusAmericanEngine__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3, double jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  QdPlusAmericanEngine::SolverType arg3 ;
  Real arg4 ;
  QdPlusAmericanEngine *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (QdPlusAmericanEngine::SolverType)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (QdPlusAmericanEngine *)new QdPlusAmericanEngine(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 ? new ext::shared_ptr<  QdPlusAmericanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QdPlusAmericanEngine__SWIG_2(void * jarg1, unsigned long jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  QdPlusAmericanEngine::SolverType arg3 ;
  QdPlusAmericanEngine *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (QdPlusAmericanEngine::SolverType)jarg3; 
  {
    try {
      result = (QdPlusAmericanEngine *)new QdPlusAmericanEngine(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 ? new ext::shared_ptr<  QdPlusAmericanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QdPlusAmericanEngine__SWIG_3(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  QdPlusAmericanEngine *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (QdPlusAmericanEngine *)new QdPlusAmericanEngine(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 ? new ext::shared_ptr<  QdPlusAmericanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QdPlusAmericanEngine__SWIG_4(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  QdPlusAmericanEngine *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  {
    try {
      result = (QdPlusAmericanEngine *)new QdPlusAmericanEngine(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  QdPlusAmericanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QdPlusAmericanEngine(void * jarg1) {
  QdPlusAmericanEngine *arg1 = (QdPlusAmericanEngine *) 0 ;
  ext::shared_ptr< QdPlusAmericanEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  QdPlusAmericanEngine > *)jarg1;
  arg1 = (QdPlusAmericanEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_QdFpIterationScheme(void * jarg1) {
  QdFpIterationScheme *arg1 = (QdFpIterationScheme *) 0 ;
  ext::shared_ptr< QdFpIterationScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  QdFpIterationScheme > *)jarg1;
  arg1 = (QdFpIterationScheme *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QdFpLegendreScheme(unsigned long jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  QdFpLegendreScheme *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (QdFpLegendreScheme *)new QdFpLegendreScheme(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 ? new ext::shared_ptr<  QdFpLegendreScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QdFpLegendreScheme(void * jarg1) {
  QdFpLegendreScheme *arg1 = (QdFpLegendreScheme *) 0 ;
  ext::shared_ptr< QdFpLegendreScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  QdFpLegendreScheme > *)jarg1;
  arg1 = (QdFpLegendreScheme *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QdFpLegendreTanhSinhScheme(unsigned long jarg1, unsigned long jarg2, unsigned long jarg3, double jarg4) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  Size arg3 ;
  Real arg4 ;
  QdFpLegendreTanhSinhScheme *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (QdFpLegendreTanhSinhScheme *)new QdFpLegendreTanhSinhScheme(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 ? new ext::shared_ptr<  QdFpLegendreTanhSinhScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QdFpLegendreTanhSinhScheme(void * jarg1) {
  QdFpLegendreTanhSinhScheme *arg1 = (QdFpLegendreTanhSinhScheme *) 0 ;
  ext::shared_ptr< QdFpLegendreTanhSinhScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  QdFpLegendreTanhSinhScheme > *)jarg1;
  arg1 = (QdFpLegendreTanhSinhScheme *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QdFpTanhSinhIterationScheme(unsigned long jarg1, unsigned long jarg2, double jarg3) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  Real arg3 ;
  QdFpTanhSinhIterationScheme *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (QdFpTanhSinhIterationScheme *)new QdFpTanhSinhIterationScheme(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 ? new ext::shared_ptr<  QdFpTanhSinhIterationScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QdFpTanhSinhIterationScheme(void * jarg1) {
  QdFpTanhSinhIterationScheme *arg1 = (QdFpTanhSinhIterationScheme *) 0 ;
  ext::shared_ptr< QdFpTanhSinhIterationScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  QdFpTanhSinhIterationScheme > *)jarg1;
  arg1 = (QdFpTanhSinhIterationScheme *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QdFpAmericanEngine__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  ext::shared_ptr< QdFpIterationScheme > arg2 ;
  QdFpAmericanEngine::FixedPointEquation arg3 ;
  QdFpAmericanEngine *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  if (jarg2) arg2 = *(ext::shared_ptr< QdFpIterationScheme > *)jarg2; 
  arg3 = (QdFpAmericanEngine::FixedPointEquation)jarg3; 
  {
    try {
      result = (QdFpAmericanEngine *)new QdFpAmericanEngine(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 ? new ext::shared_ptr<  QdFpAmericanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QdFpAmericanEngine__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  ext::shared_ptr< QdFpIterationScheme > arg2 ;
  QdFpAmericanEngine *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  if (jarg2) arg2 = *(ext::shared_ptr< QdFpIterationScheme > *)jarg2; 
  {
    try {
      result = (QdFpAmericanEngine *)new QdFpAmericanEngine(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 ? new ext::shared_ptr<  QdFpAmericanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QdFpAmericanEngine__SWIG_2(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  QdFpAmericanEngine *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  {
    try {
      result = (QdFpAmericanEngine *)new QdFpAmericanEngine(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  QdFpAmericanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


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


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QdFpAmericanEngine(void * jarg1) {
  QdFpAmericanEngine *arg1 = (QdFpAmericanEngine *) 0 ;
  ext::shared_ptr< QdFpAmericanEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  QdFpAmericanEngine > *)jarg1;
  arg1 = (QdFpAmericanEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmSchemeDesc_CrankNicolson() {
  void * jresult ;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  {
    try {
      result = FdmSchemeDesc::CrankNicolson();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(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(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(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(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(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(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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmSchemeDesc_MethodOfLines__SWIG_0(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = FdmSchemeDesc::MethodOfLines(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 FdmSchemeDesc(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmSchemeDesc_MethodOfLines__SWIG_1(double jarg1) {
  void * jresult ;
  Real arg1 ;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = FdmSchemeDesc::MethodOfLines(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmSchemeDesc_MethodOfLines__SWIG_2() {
  void * jresult ;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  {
    try {
      result = FdmSchemeDesc::MethodOfLines();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmSchemeDesc_TrBDF2() {
  void * jresult ;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  {
    try {
      result = FdmSchemeDesc::TrBDF2();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(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_FdmQuantoHelper(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5) {
  void * jresult ;
  ext::shared_ptr< YieldTermStructure > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< BlackVolTermStructure > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  ext::shared_ptr< YieldTermStructure > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  ext::shared_ptr< BlackVolTermStructure > tempnull3 ;
  FdmQuantoHelper *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< YieldTermStructure > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< BlackVolTermStructure > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (FdmQuantoHelper *)new FdmQuantoHelper((ext::shared_ptr< YieldTermStructure > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,(ext::shared_ptr< BlackVolTermStructure > 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 ? new ext::shared_ptr<  FdmQuantoHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmQuantoHelper(void * jarg1) {
  FdmQuantoHelper *arg1 = (FdmQuantoHelper *) 0 ;
  ext::shared_ptr< FdmQuantoHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmQuantoHelper > *)jarg1;
  arg1 = (FdmQuantoHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 * jarg5, unsigned int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  Real arg7 ;
  FdBlackScholesVanillaEngine::CashDividendModel arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Real)jarg7; 
  arg8 = (FdBlackScholesVanillaEngine::CashDividendModel)jarg8; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,(FdmSchemeDesc 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 = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, void * jarg5, unsigned int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  Real arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_2(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, void * jarg5, unsigned int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_3(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, void * jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_4(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_5(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_6(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_7(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_8(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, unsigned int jarg7, double jarg8, int jarg9) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  Real arg8 ;
  FdBlackScholesVanillaEngine::CashDividendModel arg9 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = (Real)jarg8; 
  arg9 = (FdBlackScholesVanillaEngine::CashDividendModel)jarg9; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4,arg5,(FdmSchemeDesc 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 = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_9(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, unsigned int jarg7, double jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  Real arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4,arg5,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_10(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, unsigned int jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4,arg5,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_11(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*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 = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_12(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_13(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_14(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_15(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_16(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, unsigned int jarg7, double jarg8, int jarg9) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  Real arg8 ;
  FdBlackScholesVanillaEngine::CashDividendModel arg9 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = (Real)jarg8; 
  arg9 = (FdBlackScholesVanillaEngine::CashDividendModel)jarg9; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc 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 = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_17(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, unsigned int jarg7, double jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  Real arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_18(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, unsigned int jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_19(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_20(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_21(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_22(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_23(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_24(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7, unsigned int jarg8, double jarg9, int jarg10) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  bool arg8 ;
  Real arg9 ;
  FdBlackScholesVanillaEngine::CashDividendModel arg10 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = (Real)jarg9; 
  arg10 = (FdBlackScholesVanillaEngine::CashDividendModel)jarg10; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5,arg6,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_25(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7, unsigned int jarg8, double jarg9) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  bool arg8 ;
  Real arg9 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5,arg6,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_26(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7, unsigned int jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  bool arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5,arg6,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_27(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*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 = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_28(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_29(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_30(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesVanillaEngine__SWIG_31(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdBlackScholesVanillaEngine(void * jarg1) {
  FdBlackScholesVanillaEngine *arg1 = (FdBlackScholesVanillaEngine *) 0 ;
  ext::shared_ptr< FdBlackScholesVanillaEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdBlackScholesVanillaEngine > *)jarg1;
  arg1 = (FdBlackScholesVanillaEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesShoutEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, void * jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesShoutEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesShoutEngine__SWIG_2(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesShoutEngine__SWIG_3(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesShoutEngine__SWIG_4(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesShoutEngine__SWIG_5(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesShoutEngine__SWIG_6(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesShoutEngine__SWIG_7(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesShoutEngine__SWIG_8(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesShoutEngine__SWIG_9(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdBlackScholesShoutEngine(void * jarg1) {
  FdBlackScholesShoutEngine *arg1 = (FdBlackScholesShoutEngine *) 0 ;
  ext::shared_ptr< FdBlackScholesShoutEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdBlackScholesShoutEngine > *)jarg1;
  arg1 = (FdBlackScholesShoutEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_0(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, double jarg6, void * jarg7) {
  void * jresult ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Real arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OrnsteinUhlenbeckProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*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 = result ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_1(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, double jarg6) {
  void * jresult ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Real arg6 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OrnsteinUhlenbeckProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > 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 ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_2(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OrnsteinUhlenbeckProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > 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 ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_3(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OrnsteinUhlenbeckProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::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 ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_4(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OrnsteinUhlenbeckProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::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 ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_5(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OrnsteinUhlenbeckProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::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 ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_6(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, double jarg7, void * jarg8) {
  void * jresult ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  DividendSchedule arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Real arg7 ;
  FdmSchemeDesc *arg8 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  DividendSchedule *argp3 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OrnsteinUhlenbeckProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  argp3 = (DividendSchedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (FdmSchemeDesc *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,arg4,arg5,arg6,arg7,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_7(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  DividendSchedule arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Real arg7 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  DividendSchedule *argp3 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OrnsteinUhlenbeckProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  argp3 = (DividendSchedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > 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 = result ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_8(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  DividendSchedule arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  DividendSchedule *argp3 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OrnsteinUhlenbeckProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  argp3 = (DividendSchedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > 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 ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_9(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  DividendSchedule arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  DividendSchedule *argp3 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OrnsteinUhlenbeckProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  argp3 = (DividendSchedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > 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 ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_10(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  DividendSchedule arg3 ;
  Size arg4 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  DividendSchedule *argp3 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OrnsteinUhlenbeckProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  argp3 = (DividendSchedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::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 ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_11(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  DividendSchedule arg3 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  DividendSchedule *argp3 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OrnsteinUhlenbeckProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  argp3 = (DividendSchedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::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 ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdOrnsteinUhlenbeckVanillaEngine(void * jarg1) {
  FdOrnsteinUhlenbeckVanillaEngine *arg1 = (FdOrnsteinUhlenbeckVanillaEngine *) 0 ;
  ext::shared_ptr< FdOrnsteinUhlenbeckVanillaEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine > *)jarg1;
  arg1 = (FdOrnsteinUhlenbeckVanillaEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 * jarg6) {
  void * jresult ;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< BatesModel > tempnull1 ;
  FdBatesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BatesModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > 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 = result ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBatesVanillaEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< BatesModel > tempnull1 ;
  FdBatesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BatesModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > 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 ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBatesVanillaEngine__SWIG_2(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< BatesModel > tempnull1 ;
  FdBatesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BatesModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > 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 ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBatesVanillaEngine__SWIG_3(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< BatesModel > tempnull1 ;
  FdBatesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BatesModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > 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 ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBatesVanillaEngine__SWIG_4(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< BatesModel > tempnull1 ;
  FdBatesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BatesModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > 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 ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBatesVanillaEngine__SWIG_5(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  ext::shared_ptr< BatesModel > tempnull1 ;
  FdBatesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BatesModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBatesVanillaEngine__SWIG_6(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7) {
  void * jresult ;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< BatesModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBatesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BatesModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > 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 = result ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBatesVanillaEngine__SWIG_7(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  ext::shared_ptr< BatesModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBatesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BatesModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > 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 = result ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBatesVanillaEngine__SWIG_8(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< BatesModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBatesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BatesModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > 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 ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBatesVanillaEngine__SWIG_9(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< BatesModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBatesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BatesModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > 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 ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBatesVanillaEngine__SWIG_10(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  ext::shared_ptr< BatesModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBatesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BatesModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > 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 ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBatesVanillaEngine__SWIG_11(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< BatesModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBatesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BatesModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > 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 ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdBatesVanillaEngine(void * jarg1) {
  FdBatesVanillaEngine *arg1 = (FdBatesVanillaEngine *) 0 ;
  ext::shared_ptr< FdBatesVanillaEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdBatesVanillaEngine > *)jarg1;
  arg1 = (FdBatesVanillaEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, void * jarg7, double jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg7 = 0 ;
  Real arg8 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull7 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg7 : &tempnull7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg7 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull7 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg7 : &tempnull7; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_2(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > 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 = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_3(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_4(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_5(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_6(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_7(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_8(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7, void * jarg8, double jarg9) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = 0 ;
  Real arg9 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull2 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull8 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg8 : &tempnull8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,(ext::shared_ptr< LocalVolTermStructure > 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 = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_9(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull2 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull8 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg8 : &tempnull8; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_10(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull2 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*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 = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_11(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull2 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_12(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull2 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_13(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull2 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_14(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull2 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_15(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull2 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_16(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7, void * jarg8, double jarg9) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = 0 ;
  Real arg9 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull8 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg8 : &tempnull8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,(ext::shared_ptr< LocalVolTermStructure > 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 = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_17(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull8 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg8 : &tempnull8; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_18(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > 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 = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_19(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > 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 = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_20(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_21(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_22(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_23(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_24(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, void * jarg8, void * jarg9, double jarg10) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  FdmSchemeDesc *arg8 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg9 = 0 ;
  Real arg10 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull9 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (FdmSchemeDesc *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg9 = jarg9 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg9 : &tempnull9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5,arg6,arg7,(FdmSchemeDesc const &)*arg8,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_25(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  FdmSchemeDesc *arg8 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg9 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull9 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (FdmSchemeDesc *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg9 = jarg9 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg9 : &tempnull9; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5,arg6,arg7,(FdmSchemeDesc const &)*arg8,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_26(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, void * jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  FdmSchemeDesc *arg8 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (FdmSchemeDesc *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5,arg6,arg7,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_27(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_28(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_29(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_30(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonVanillaEngine__SWIG_31(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  FdHestonVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdHestonVanillaEngine(void * jarg1) {
  FdHestonVanillaEngine *arg1 = (FdHestonVanillaEngine *) 0 ;
  ext::shared_ptr< FdHestonVanillaEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdHestonVanillaEngine > *)jarg1;
  arg1 = (FdHestonVanillaEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticCEVEngine(double jarg1, double jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  AnalyticCEVEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticCEVEngine *)new AnalyticCEVEngine(arg1,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 ? new ext::shared_ptr<  AnalyticCEVEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticCEVEngine(void * jarg1) {
  AnalyticCEVEngine *arg1 = (AnalyticCEVEngine *) 0 ;
  ext::shared_ptr< AnalyticCEVEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticCEVEngine > *)jarg1;
  arg1 = (AnalyticCEVEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdCEVVanillaEngine__SWIG_0(double jarg1, double jarg2, double jarg3, void * jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, double jarg8, double jarg9, void * jarg10) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Real arg8 ;
  Real arg9 ;
  FdmSchemeDesc *arg10 = 0 ;
  FdCEVVanillaEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (FdmSchemeDesc *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdCEVVanillaEngine *)new FdCEVVanillaEngine(arg1,arg2,arg3,(Handle< YieldTermStructure > const &)*arg4,arg5,arg6,arg7,arg8,arg9,(FdmSchemeDesc 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 = result ? new ext::shared_ptr<  FdCEVVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdCEVVanillaEngine__SWIG_1(double jarg1, double jarg2, double jarg3, void * jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, double jarg8, double jarg9) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Real arg8 ;
  Real arg9 ;
  FdCEVVanillaEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (FdCEVVanillaEngine *)new FdCEVVanillaEngine(arg1,arg2,arg3,(Handle< YieldTermStructure > 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 ? new ext::shared_ptr<  FdCEVVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdCEVVanillaEngine__SWIG_2(double jarg1, double jarg2, double jarg3, void * jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, double jarg8) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Real arg8 ;
  FdCEVVanillaEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (FdCEVVanillaEngine *)new FdCEVVanillaEngine(arg1,arg2,arg3,(Handle< YieldTermStructure > 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 ? new ext::shared_ptr<  FdCEVVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdCEVVanillaEngine__SWIG_3(double jarg1, double jarg2, double jarg3, void * jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  FdCEVVanillaEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (FdCEVVanillaEngine *)new FdCEVVanillaEngine(arg1,arg2,arg3,(Handle< YieldTermStructure > 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 ? new ext::shared_ptr<  FdCEVVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdCEVVanillaEngine__SWIG_4(double jarg1, double jarg2, double jarg3, void * jarg4, unsigned long jarg5, unsigned long jarg6) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  FdCEVVanillaEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdCEVVanillaEngine *)new FdCEVVanillaEngine(arg1,arg2,arg3,(Handle< YieldTermStructure > 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 ? new ext::shared_ptr<  FdCEVVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdCEVVanillaEngine__SWIG_5(double jarg1, double jarg2, double jarg3, void * jarg4, unsigned long jarg5) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  Size arg5 ;
  FdCEVVanillaEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdCEVVanillaEngine *)new FdCEVVanillaEngine(arg1,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 = result ? new ext::shared_ptr<  FdCEVVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdCEVVanillaEngine__SWIG_6(double jarg1, double jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  FdCEVVanillaEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdCEVVanillaEngine *)new FdCEVVanillaEngine(arg1,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 ? new ext::shared_ptr<  FdCEVVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdCEVVanillaEngine(void * jarg1) {
  FdCEVVanillaEngine *arg1 = (FdCEVVanillaEngine *) 0 ;
  ext::shared_ptr< FdCEVVanillaEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdCEVVanillaEngine > *)jarg1;
  arg1 = (FdCEVVanillaEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSabrVanillaEngine__SWIG_0(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, void * jarg6, unsigned long jarg7, unsigned long jarg8, unsigned long jarg9, unsigned long jarg10, double jarg11, double jarg12, void * jarg13) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Size arg7 ;
  Size arg8 ;
  Size arg9 ;
  Size arg10 ;
  Real arg11 ;
  Real arg12 ;
  FdmSchemeDesc *arg13 = 0 ;
  FdSabrVanillaEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg7 = (Size)jarg7; 
  arg8 = (Size)jarg8; 
  arg9 = (Size)jarg9; 
  arg10 = (Size)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (Real)jarg12; 
  arg13 = (FdmSchemeDesc *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdSabrVanillaEngine *)new FdSabrVanillaEngine(arg1,arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,(FdmSchemeDesc 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 = result ? new ext::shared_ptr<  FdSabrVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSabrVanillaEngine__SWIG_1(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, void * jarg6, unsigned long jarg7, unsigned long jarg8, unsigned long jarg9, unsigned long jarg10, double jarg11, double jarg12) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Size arg7 ;
  Size arg8 ;
  Size arg9 ;
  Size arg10 ;
  Real arg11 ;
  Real arg12 ;
  FdSabrVanillaEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg7 = (Size)jarg7; 
  arg8 = (Size)jarg8; 
  arg9 = (Size)jarg9; 
  arg10 = (Size)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (Real)jarg12; 
  {
    try {
      result = (FdSabrVanillaEngine *)new FdSabrVanillaEngine(arg1,arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*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 ? new ext::shared_ptr<  FdSabrVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSabrVanillaEngine__SWIG_2(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, void * jarg6, unsigned long jarg7, unsigned long jarg8, unsigned long jarg9, unsigned long jarg10, double jarg11) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Size arg7 ;
  Size arg8 ;
  Size arg9 ;
  Size arg10 ;
  Real arg11 ;
  FdSabrVanillaEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg7 = (Size)jarg7; 
  arg8 = (Size)jarg8; 
  arg9 = (Size)jarg9; 
  arg10 = (Size)jarg10; 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (FdSabrVanillaEngine *)new FdSabrVanillaEngine(arg1,arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*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 ? new ext::shared_ptr<  FdSabrVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSabrVanillaEngine__SWIG_3(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, void * jarg6, unsigned long jarg7, unsigned long jarg8, unsigned long jarg9, unsigned long jarg10) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Size arg7 ;
  Size arg8 ;
  Size arg9 ;
  Size arg10 ;
  FdSabrVanillaEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg7 = (Size)jarg7; 
  arg8 = (Size)jarg8; 
  arg9 = (Size)jarg9; 
  arg10 = (Size)jarg10; 
  {
    try {
      result = (FdSabrVanillaEngine *)new FdSabrVanillaEngine(arg1,arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > 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 = result ? new ext::shared_ptr<  FdSabrVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSabrVanillaEngine__SWIG_4(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, void * jarg6, unsigned long jarg7, unsigned long jarg8, unsigned long jarg9) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Size arg7 ;
  Size arg8 ;
  Size arg9 ;
  FdSabrVanillaEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg7 = (Size)jarg7; 
  arg8 = (Size)jarg8; 
  arg9 = (Size)jarg9; 
  {
    try {
      result = (FdSabrVanillaEngine *)new FdSabrVanillaEngine(arg1,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 = result ? new ext::shared_ptr<  FdSabrVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSabrVanillaEngine__SWIG_5(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, void * jarg6, unsigned long jarg7, unsigned long jarg8) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Size arg7 ;
  Size arg8 ;
  FdSabrVanillaEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg7 = (Size)jarg7; 
  arg8 = (Size)jarg8; 
  {
    try {
      result = (FdSabrVanillaEngine *)new FdSabrVanillaEngine(arg1,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 = result ? new ext::shared_ptr<  FdSabrVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSabrVanillaEngine__SWIG_6(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, void * jarg6, unsigned long jarg7) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Size arg7 ;
  FdSabrVanillaEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (FdSabrVanillaEngine *)new FdSabrVanillaEngine(arg1,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 = result ? new ext::shared_ptr<  FdSabrVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSabrVanillaEngine__SWIG_7(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, void * jarg6) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  FdSabrVanillaEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdSabrVanillaEngine *)new FdSabrVanillaEngine(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 = result ? new ext::shared_ptr<  FdSabrVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdSabrVanillaEngine(void * jarg1) {
  FdSabrVanillaEngine *arg1 = (FdSabrVanillaEngine *) 0 ;
  ext::shared_ptr< FdSabrVanillaEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdSabrVanillaEngine > *)jarg1;
  arg1 = (FdSabrVanillaEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonHullWhiteVanillaEngine__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, unsigned long jarg8, unsigned int jarg9, void * jarg10) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Size arg8 ;
  bool arg9 ;
  FdmSchemeDesc *arg10 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  if (jarg2) arg2 = *(ext::shared_ptr< HullWhiteProcess > *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Size)jarg8; 
  arg9 = jarg9 ? true : false; 
  arg10 = (FdmSchemeDesc *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(FdmSchemeDesc 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 = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonHullWhiteVanillaEngine__SWIG_1(void * jarg1, void * jarg2, double jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, unsigned long jarg8, unsigned int jarg9) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Size arg8 ;
  bool arg9 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  if (jarg2) arg2 = *(ext::shared_ptr< HullWhiteProcess > *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Size)jarg8; 
  arg9 = jarg9 ? true : false; 
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*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 ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonHullWhiteVanillaEngine__SWIG_2(void * jarg1, void * jarg2, double jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, unsigned long jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Size arg8 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  if (jarg2) arg2 = *(ext::shared_ptr< HullWhiteProcess > *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Size)jarg8; 
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*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 ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonHullWhiteVanillaEngine__SWIG_3(void * jarg1, void * jarg2, double jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  if (jarg2) arg2 = *(ext::shared_ptr< HullWhiteProcess > *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*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 ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonHullWhiteVanillaEngine__SWIG_4(void * jarg1, void * jarg2, double jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  if (jarg2) arg2 = *(ext::shared_ptr< HullWhiteProcess > *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > 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 = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonHullWhiteVanillaEngine__SWIG_5(void * jarg1, void * jarg2, double jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  if (jarg2) arg2 = *(ext::shared_ptr< HullWhiteProcess > *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonHullWhiteVanillaEngine__SWIG_6(void * jarg1, void * jarg2, double jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  Real arg3 ;
  Size arg4 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  if (jarg2) arg2 = *(ext::shared_ptr< HullWhiteProcess > *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonHullWhiteVanillaEngine__SWIG_7(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  Real arg3 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  if (jarg2) arg2 = *(ext::shared_ptr< HullWhiteProcess > *)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonHullWhiteVanillaEngine__SWIG_8(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, unsigned long jarg8, unsigned long jarg9, unsigned int jarg10, void * jarg11) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  DividendSchedule arg3 ;
  Real arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Size arg8 ;
  Size arg9 ;
  bool arg10 ;
  FdmSchemeDesc *arg11 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp3 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  if (jarg2) arg2 = *(ext::shared_ptr< HullWhiteProcess > *)jarg2; 
  argp3 = (DividendSchedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Size)jarg8; 
  arg9 = (Size)jarg9; 
  arg10 = jarg10 ? true : false; 
  arg11 = (FdmSchemeDesc *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(FdmSchemeDesc 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 = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonHullWhiteVanillaEngine__SWIG_9(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, unsigned long jarg8, unsigned long jarg9, unsigned int jarg10) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  DividendSchedule arg3 ;
  Real arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Size arg8 ;
  Size arg9 ;
  bool arg10 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp3 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  if (jarg2) arg2 = *(ext::shared_ptr< HullWhiteProcess > *)jarg2; 
  argp3 = (DividendSchedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Size)jarg8; 
  arg9 = (Size)jarg9; 
  arg10 = jarg10 ? true : false; 
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,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 = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonHullWhiteVanillaEngine__SWIG_10(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, unsigned long jarg8, unsigned long jarg9) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  DividendSchedule arg3 ;
  Real arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Size arg8 ;
  Size arg9 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp3 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  if (jarg2) arg2 = *(ext::shared_ptr< HullWhiteProcess > *)jarg2; 
  argp3 = (DividendSchedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Size)jarg8; 
  arg9 = (Size)jarg9; 
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*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 ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonHullWhiteVanillaEngine__SWIG_11(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, unsigned long jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  DividendSchedule arg3 ;
  Real arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Size arg8 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp3 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  if (jarg2) arg2 = *(ext::shared_ptr< HullWhiteProcess > *)jarg2; 
  argp3 = (DividendSchedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Size)jarg8; 
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*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 ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonHullWhiteVanillaEngine__SWIG_12(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  DividendSchedule arg3 ;
  Real arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp3 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  if (jarg2) arg2 = *(ext::shared_ptr< HullWhiteProcess > *)jarg2; 
  argp3 = (DividendSchedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*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 ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonHullWhiteVanillaEngine__SWIG_13(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned long jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  DividendSchedule arg3 ;
  Real arg4 ;
  Size arg5 ;
  Size arg6 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp3 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  if (jarg2) arg2 = *(ext::shared_ptr< HullWhiteProcess > *)jarg2; 
  argp3 = (DividendSchedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > 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 = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonHullWhiteVanillaEngine__SWIG_14(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  DividendSchedule arg3 ;
  Real arg4 ;
  Size arg5 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp3 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  if (jarg2) arg2 = *(ext::shared_ptr< HullWhiteProcess > *)jarg2; 
  argp3 = (DividendSchedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonHullWhiteVanillaEngine__SWIG_15(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  DividendSchedule arg3 ;
  Real arg4 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp3 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  if (jarg2) arg2 = *(ext::shared_ptr< HullWhiteProcess > *)jarg2; 
  argp3 = (DividendSchedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdHestonHullWhiteVanillaEngine(void * jarg1) {
  FdHestonHullWhiteVanillaEngine *arg1 = (FdHestonHullWhiteVanillaEngine *) 0 ;
  ext::shared_ptr< FdHestonHullWhiteVanillaEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *)jarg1;
  arg1 = (FdHestonHullWhiteVanillaEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticHestonHullWhiteEngine__SWIG_0(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > arg2 ;
  Size arg3 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< HullWhite > *argp2 ;
  AnalyticHestonHullWhiteEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (ext::shared_ptr< HullWhite > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::shared_ptr< HullWhite >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (AnalyticHestonHullWhiteEngine *)new AnalyticHestonHullWhiteEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  AnalyticHestonHullWhiteEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticHestonHullWhiteEngine__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > arg2 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< HullWhite > *argp2 ;
  AnalyticHestonHullWhiteEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (ext::shared_ptr< HullWhite > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::shared_ptr< HullWhite >", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (AnalyticHestonHullWhiteEngine *)new AnalyticHestonHullWhiteEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  AnalyticHestonHullWhiteEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticHestonHullWhiteEngine__SWIG_2(void * jarg1, void * jarg2, double jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > arg2 ;
  Real arg3 ;
  Size arg4 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< HullWhite > *argp2 ;
  AnalyticHestonHullWhiteEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (ext::shared_ptr< HullWhite > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::shared_ptr< HullWhite >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (AnalyticHestonHullWhiteEngine *)new AnalyticHestonHullWhiteEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  AnalyticHestonHullWhiteEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticHestonHullWhiteEngine(void * jarg1) {
  AnalyticHestonHullWhiteEngine *arg1 = (AnalyticHestonHullWhiteEngine *) 0 ;
  ext::shared_ptr< AnalyticHestonHullWhiteEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticHestonHullWhiteEngine > *)jarg1;
  arg1 = (AnalyticHestonHullWhiteEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticH1HWEngine__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > *arg2 = 0 ;
  Real arg3 ;
  Size arg4 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  AnalyticH1HWEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (ext::shared_ptr< HullWhite > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ext::shared_ptr< HullWhite > const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (AnalyticH1HWEngine *)new AnalyticH1HWEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< HullWhite > 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 ? new ext::shared_ptr<  AnalyticH1HWEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticH1HWEngine__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  AnalyticH1HWEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (ext::shared_ptr< HullWhite > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ext::shared_ptr< HullWhite > const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (AnalyticH1HWEngine *)new AnalyticH1HWEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< HullWhite > 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 ? new ext::shared_ptr<  AnalyticH1HWEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticH1HWEngine__SWIG_2(void * jarg1, void * jarg2, double jarg3, double jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  Size arg5 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  AnalyticH1HWEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (ext::shared_ptr< HullWhite > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ext::shared_ptr< HullWhite > const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (AnalyticH1HWEngine *)new AnalyticH1HWEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< HullWhite > 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 ? new ext::shared_ptr<  AnalyticH1HWEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticH1HWEngine(void * jarg1) {
  AnalyticH1HWEngine *arg1 = (AnalyticH1HWEngine *) 0 ;
  ext::shared_ptr< AnalyticH1HWEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticH1HWEngine > *)jarg1;
  arg1 = (AnalyticH1HWEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ForwardEuropeanEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (ForwardEuropeanEngine *)new ForwardEuropeanEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  ForwardEuropeanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ForwardEuropeanEngine(void * jarg1) {
  ForwardEuropeanEngine *arg1 = (ForwardEuropeanEngine *) 0 ;
  ext::shared_ptr< ForwardEuropeanEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ForwardEuropeanEngine > *)jarg1;
  arg1 = (ForwardEuropeanEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< BlackVolTermStructure > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  QuantoEuropeanEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< BlackVolTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (QuantoEuropeanEngine *)new QuantoEuropeanEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  QuantoEuropeanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QuantoEuropeanEngine(void * jarg1) {
  QuantoEuropeanEngine *arg1 = (QuantoEuropeanEngine *) 0 ;
  ext::shared_ptr< QuantoEuropeanEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  QuantoEuropeanEngine > *)jarg1;
  arg1 = (QuantoEuropeanEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< BlackVolTermStructure > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  QuantoForwardEuropeanEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< BlackVolTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (QuantoForwardEuropeanEngine *)new QuantoForwardEuropeanEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  QuantoForwardEuropeanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QuantoForwardEuropeanEngine(void * jarg1) {
  QuantoForwardEuropeanEngine *arg1 = (QuantoForwardEuropeanEngine *) 0 ;
  ext::shared_ptr< QuantoForwardEuropeanEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  QuantoForwardEuropeanEngine > *)jarg1;
  arg1 = (QuantoForwardEuropeanEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticHestonForwardEuropeanEngine__SWIG_0(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  AnalyticHestonForwardEuropeanEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (AnalyticHestonForwardEuropeanEngine *)new AnalyticHestonForwardEuropeanEngine((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  AnalyticHestonForwardEuropeanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticHestonForwardEuropeanEngine__SWIG_1(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  AnalyticHestonForwardEuropeanEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticHestonForwardEuropeanEngine *)new AnalyticHestonForwardEuropeanEngine((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticHestonForwardEuropeanEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticHestonForwardEuropeanEngine(void * jarg1) {
  AnalyticHestonForwardEuropeanEngine *arg1 = (AnalyticHestonForwardEuropeanEngine *) 0 ;
  ext::shared_ptr< AnalyticHestonForwardEuropeanEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticHestonForwardEuropeanEngine > *)jarg1;
  arg1 = (AnalyticHestonForwardEuropeanEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanBSEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< PseudoRandom > *)new_MCForwardEuropeanBSEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanBSEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< PseudoRandom > *)new_MCForwardEuropeanBSEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanBSEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< PseudoRandom > *)new_MCForwardEuropeanBSEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanBSEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< PseudoRandom > *)new_MCForwardEuropeanBSEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanBSEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< PseudoRandom > *)new_MCForwardEuropeanBSEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanBSEngine__SWIG_5(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< PseudoRandom > *)new_MCForwardEuropeanBSEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanBSEngine__SWIG_6(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< PseudoRandom > *)new_MCForwardEuropeanBSEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanBSEngine__SWIG_7(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< PseudoRandom > *)new_MCForwardEuropeanBSEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanBSEngine__SWIG_8(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< PseudoRandom > *)new_MCForwardEuropeanBSEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPRForwardEuropeanBSEngine(void * jarg1) {
  MCForwardEuropeanBSEngine< PseudoRandom > *arg1 = (MCForwardEuropeanBSEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCForwardEuropeanBSEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCForwardEuropeanBSEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCForwardEuropeanBSEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanBSEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< LowDiscrepancy > *)new_MCForwardEuropeanBSEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanBSEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< LowDiscrepancy > *)new_MCForwardEuropeanBSEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanBSEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< LowDiscrepancy > *)new_MCForwardEuropeanBSEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanBSEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< LowDiscrepancy > *)new_MCForwardEuropeanBSEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanBSEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< LowDiscrepancy > *)new_MCForwardEuropeanBSEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanBSEngine__SWIG_5(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< LowDiscrepancy > *)new_MCForwardEuropeanBSEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanBSEngine__SWIG_6(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< LowDiscrepancy > *)new_MCForwardEuropeanBSEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanBSEngine__SWIG_7(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< LowDiscrepancy > *)new_MCForwardEuropeanBSEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanBSEngine__SWIG_8(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCForwardEuropeanBSEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCForwardEuropeanBSEngine< LowDiscrepancy > *)new_MCForwardEuropeanBSEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDForwardEuropeanBSEngine(void * jarg1) {
  MCForwardEuropeanBSEngine< LowDiscrepancy > *arg1 = (MCForwardEuropeanBSEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCForwardEuropeanBSEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCForwardEuropeanBSEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCForwardEuropeanBSEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanHestonEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7, long jarg8, unsigned int jarg9) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  BigInteger arg8 ;
  bool arg9 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (BigInteger)jarg8; 
  arg9 = jarg9 ? true : false; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< PseudoRandom > *)new_MCForwardEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanHestonEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7, long jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  BigInteger arg8 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (BigInteger)jarg8; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< PseudoRandom > *)new_MCForwardEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanHestonEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< PseudoRandom > *)new_MCForwardEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanHestonEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< PseudoRandom > *)new_MCForwardEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 = result ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanHestonEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< PseudoRandom > *)new_MCForwardEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanHestonEngine__SWIG_5(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< PseudoRandom > *)new_MCForwardEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanHestonEngine__SWIG_6(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< PseudoRandom > *)new_MCForwardEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanHestonEngine__SWIG_7(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< PseudoRandom > *)new_MCForwardEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRForwardEuropeanHestonEngine__SWIG_8(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< PseudoRandom > *)new_MCForwardEuropeanHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPRForwardEuropeanHestonEngine(void * jarg1) {
  MCForwardEuropeanHestonEngine< PseudoRandom > *arg1 = (MCForwardEuropeanHestonEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCForwardEuropeanHestonEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCForwardEuropeanHestonEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCForwardEuropeanHestonEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanHestonEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7, long jarg8, unsigned int jarg9) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  BigInteger arg8 ;
  bool arg9 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (BigInteger)jarg8; 
  arg9 = jarg9 ? true : false; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< LowDiscrepancy > *)new_MCForwardEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanHestonEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7, long jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  BigInteger arg8 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (BigInteger)jarg8; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< LowDiscrepancy > *)new_MCForwardEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanHestonEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< LowDiscrepancy > *)new_MCForwardEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanHestonEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< LowDiscrepancy > *)new_MCForwardEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 = result ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanHestonEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< LowDiscrepancy > *)new_MCForwardEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanHestonEngine__SWIG_5(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< LowDiscrepancy > *)new_MCForwardEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanHestonEngine__SWIG_6(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< LowDiscrepancy > *)new_MCForwardEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanHestonEngine__SWIG_7(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< LowDiscrepancy > *)new_MCForwardEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDForwardEuropeanHestonEngine__SWIG_8(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCForwardEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCForwardEuropeanHestonEngine< LowDiscrepancy > *)new_MCForwardEuropeanHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDForwardEuropeanHestonEngine(void * jarg1) {
  MCForwardEuropeanHestonEngine< LowDiscrepancy > *arg1 = (MCForwardEuropeanHestonEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCForwardEuropeanHestonEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCForwardEuropeanHestonEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCForwardEuropeanHestonEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< StrikedTypePayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull1 ;
  BlackCalculator *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (BlackCalculator *)new BlackCalculator((ext::shared_ptr< StrikedTypePayoff > 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 ;
  ext::shared_ptr< StrikedTypePayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull1 ;
  BlackCalculator *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (BlackCalculator *)new BlackCalculator((ext::shared_ptr< StrikedTypePayoff > 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_strikeGamma(void * jarg1) {
  double jresult ;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real result;
  
  arg1 = (BlackCalculator *)jarg1; 
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->strikeGamma();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_VarianceGammaEngine(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< VarianceGammaProcess > *arg1 = 0 ;
  ext::shared_ptr< VarianceGammaProcess > tempnull1 ;
  VarianceGammaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< VarianceGammaProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (VarianceGammaEngine *)new VarianceGammaEngine((ext::shared_ptr< VarianceGammaProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  VarianceGammaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_VarianceGammaEngine(void * jarg1) {
  VarianceGammaEngine *arg1 = (VarianceGammaEngine *) 0 ;
  ext::shared_ptr< VarianceGammaEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  VarianceGammaEngine > *)jarg1;
  arg1 = (VarianceGammaEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< VarianceGammaProcess > *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< VarianceGammaProcess > tempnull1 ;
  FFTVarianceGammaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< VarianceGammaProcess > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (FFTVarianceGammaEngine *)new FFTVarianceGammaEngine((ext::shared_ptr< VarianceGammaProcess > 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 ? new ext::shared_ptr<  FFTVarianceGammaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FFTVarianceGammaEngine__SWIG_1(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< VarianceGammaProcess > *arg1 = 0 ;
  ext::shared_ptr< VarianceGammaProcess > tempnull1 ;
  FFTVarianceGammaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< VarianceGammaProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (FFTVarianceGammaEngine *)new FFTVarianceGammaEngine((ext::shared_ptr< VarianceGammaProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FFTVarianceGammaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FFTVarianceGammaEngine_precalculate(void * jarg1, void * jarg2) {
  FFTVarianceGammaEngine *arg1 = (FFTVarianceGammaEngine *) 0 ;
  std::vector< ext::shared_ptr< Instrument > > *arg2 = 0 ;
  ext::shared_ptr< FFTVarianceGammaEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FFTVarianceGammaEngine > *)jarg1;
  arg1 = (FFTVarianceGammaEngine *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< Instrument > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Instrument > > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->precalculate((std::vector< ext::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) {
  FFTVarianceGammaEngine *arg1 = (FFTVarianceGammaEngine *) 0 ;
  ext::shared_ptr< FFTVarianceGammaEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FFTVarianceGammaEngine > *)jarg1;
  arg1 = (FFTVarianceGammaEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GJRGARCHModel(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  GJRGARCHModel *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (GJRGARCHModel *)new GJRGARCHModel((ext::shared_ptr< GJRGARCHProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  GJRGARCHModel >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_GJRGARCHModel_omega(void * jarg1) {
  double jresult ;
  GJRGARCHModel *arg1 = (GJRGARCHModel *) 0 ;
  ext::shared_ptr< GJRGARCHModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const GJRGARCHModel > *)jarg1;
  arg1 = (GJRGARCHModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((GJRGARCHModel const *)arg1)->omega();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_GJRGARCHModel_alpha(void * jarg1) {
  double jresult ;
  GJRGARCHModel *arg1 = (GJRGARCHModel *) 0 ;
  ext::shared_ptr< GJRGARCHModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const GJRGARCHModel > *)jarg1;
  arg1 = (GJRGARCHModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((GJRGARCHModel 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_GJRGARCHModel_beta(void * jarg1) {
  double jresult ;
  GJRGARCHModel *arg1 = (GJRGARCHModel *) 0 ;
  ext::shared_ptr< GJRGARCHModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const GJRGARCHModel > *)jarg1;
  arg1 = (GJRGARCHModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((GJRGARCHModel 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 double SWIGSTDCALL CSharp_QuantLib_GJRGARCHModel_gamma(void * jarg1) {
  double jresult ;
  GJRGARCHModel *arg1 = (GJRGARCHModel *) 0 ;
  ext::shared_ptr< GJRGARCHModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const GJRGARCHModel > *)jarg1;
  arg1 = (GJRGARCHModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((GJRGARCHModel const *)arg1)->gamma();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_GJRGARCHModel_lambda(void * jarg1) {
  double jresult ;
  GJRGARCHModel *arg1 = (GJRGARCHModel *) 0 ;
  ext::shared_ptr< GJRGARCHModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const GJRGARCHModel > *)jarg1;
  arg1 = (GJRGARCHModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((GJRGARCHModel const *)arg1)->lambda();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_GJRGARCHModel_v0(void * jarg1) {
  double jresult ;
  GJRGARCHModel *arg1 = (GJRGARCHModel *) 0 ;
  ext::shared_ptr< GJRGARCHModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const GJRGARCHModel > *)jarg1;
  arg1 = (GJRGARCHModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((GJRGARCHModel const *)arg1)->v0();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_GJRGARCHModel(void * jarg1) {
  GJRGARCHModel *arg1 = (GJRGARCHModel *) 0 ;
  ext::shared_ptr< GJRGARCHModel > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GJRGARCHModel > *)jarg1;
  arg1 = (GJRGARCHModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticGJRGARCHEngine(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHModel > *arg1 = 0 ;
  ext::shared_ptr< GJRGARCHModel > tempnull1 ;
  AnalyticGJRGARCHEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticGJRGARCHEngine *)new AnalyticGJRGARCHEngine((ext::shared_ptr< GJRGARCHModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticGJRGARCHEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticGJRGARCHEngine(void * jarg1) {
  AnalyticGJRGARCHEngine *arg1 = (AnalyticGJRGARCHEngine *) 0 ;
  ext::shared_ptr< AnalyticGJRGARCHEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticGJRGARCHEngine > *)jarg1;
  arg1 = (AnalyticGJRGARCHEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanGJRGARCHEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7, long jarg8) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  BigInteger arg8 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  MCEuropeanGJRGARCHEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (BigInteger)jarg8; 
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< PseudoRandom > *)new_MCEuropeanGJRGARCHEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GJRGARCHProcess > const &)*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 ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanGJRGARCHEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  MCEuropeanGJRGARCHEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< PseudoRandom > *)new_MCEuropeanGJRGARCHEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GJRGARCHProcess > const &)*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 ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanGJRGARCHEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  MCEuropeanGJRGARCHEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< PseudoRandom > *)new_MCEuropeanGJRGARCHEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GJRGARCHProcess > 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 = result ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanGJRGARCHEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  MCEuropeanGJRGARCHEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< PseudoRandom > *)new_MCEuropeanGJRGARCHEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GJRGARCHProcess > 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 ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanGJRGARCHEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  MCEuropeanGJRGARCHEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< PseudoRandom > *)new_MCEuropeanGJRGARCHEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GJRGARCHProcess > 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 ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanGJRGARCHEngine__SWIG_5(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  MCEuropeanGJRGARCHEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< PseudoRandom > *)new_MCEuropeanGJRGARCHEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GJRGARCHProcess > 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 ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanGJRGARCHEngine__SWIG_6(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  MCEuropeanGJRGARCHEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< PseudoRandom > *)new_MCEuropeanGJRGARCHEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GJRGARCHProcess > 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 ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanGJRGARCHEngine__SWIG_7(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  MCEuropeanGJRGARCHEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< PseudoRandom > *)new_MCEuropeanGJRGARCHEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GJRGARCHProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPREuropeanGJRGARCHEngine(void * jarg1) {
  MCEuropeanGJRGARCHEngine< PseudoRandom > *arg1 = (MCEuropeanGJRGARCHEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCEuropeanGJRGARCHEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCEuropeanGJRGARCHEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCEuropeanGJRGARCHEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanGJRGARCHEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7, long jarg8) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  BigInteger arg8 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  MCEuropeanGJRGARCHEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (BigInteger)jarg8; 
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< LowDiscrepancy > *)new_MCEuropeanGJRGARCHEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GJRGARCHProcess > const &)*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 ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanGJRGARCHEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  MCEuropeanGJRGARCHEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< LowDiscrepancy > *)new_MCEuropeanGJRGARCHEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GJRGARCHProcess > const &)*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 ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanGJRGARCHEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5, double jarg6) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  MCEuropeanGJRGARCHEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< LowDiscrepancy > *)new_MCEuropeanGJRGARCHEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GJRGARCHProcess > 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 = result ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanGJRGARCHEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, int jarg5) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  MCEuropeanGJRGARCHEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< LowDiscrepancy > *)new_MCEuropeanGJRGARCHEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GJRGARCHProcess > 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 ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanGJRGARCHEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  MCEuropeanGJRGARCHEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< LowDiscrepancy > *)new_MCEuropeanGJRGARCHEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GJRGARCHProcess > 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 ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanGJRGARCHEngine__SWIG_5(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  MCEuropeanGJRGARCHEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< LowDiscrepancy > *)new_MCEuropeanGJRGARCHEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GJRGARCHProcess > 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 ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanGJRGARCHEngine__SWIG_6(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  MCEuropeanGJRGARCHEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< LowDiscrepancy > *)new_MCEuropeanGJRGARCHEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GJRGARCHProcess > 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 ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanGJRGARCHEngine__SWIG_7(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  ext::shared_ptr< GJRGARCHProcess > tempnull1 ;
  MCEuropeanGJRGARCHEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GJRGARCHProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< LowDiscrepancy > *)new_MCEuropeanGJRGARCHEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GJRGARCHProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDEuropeanGJRGARCHEngine(void * jarg1) {
  MCEuropeanGJRGARCHEngine< LowDiscrepancy > *arg1 = (MCEuropeanGJRGARCHEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCEuropeanGJRGARCHEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCEuropeanGJRGARCHEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCEuropeanGJRGARCHEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MargrabeOption(int jarg1, int jarg2, void * jarg3) {
  void * jresult ;
  Integer arg1 ;
  Integer arg2 ;
  ext::shared_ptr< Exercise > *arg3 = 0 ;
  ext::shared_ptr< Exercise > tempnull3 ;
  MargrabeOption *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Integer)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< Exercise > *)jarg3 : &tempnull3; 
  {
    try {
      result = (MargrabeOption *)new MargrabeOption(arg1,arg2,(ext::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 = result ? new ext::shared_ptr<  MargrabeOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MargrabeOption_delta1(void * jarg1) {
  double jresult ;
  MargrabeOption *arg1 = (MargrabeOption *) 0 ;
  ext::shared_ptr< MargrabeOption const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const MargrabeOption > *)jarg1;
  arg1 = (MargrabeOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((MargrabeOption const *)arg1)->delta1();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MargrabeOption_delta2(void * jarg1) {
  double jresult ;
  MargrabeOption *arg1 = (MargrabeOption *) 0 ;
  ext::shared_ptr< MargrabeOption const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const MargrabeOption > *)jarg1;
  arg1 = (MargrabeOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((MargrabeOption const *)arg1)->delta2();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MargrabeOption_gamma1(void * jarg1) {
  double jresult ;
  MargrabeOption *arg1 = (MargrabeOption *) 0 ;
  ext::shared_ptr< MargrabeOption const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const MargrabeOption > *)jarg1;
  arg1 = (MargrabeOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((MargrabeOption const *)arg1)->gamma1();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MargrabeOption_gamma2(void * jarg1) {
  double jresult ;
  MargrabeOption *arg1 = (MargrabeOption *) 0 ;
  ext::shared_ptr< MargrabeOption const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const MargrabeOption > *)jarg1;
  arg1 = (MargrabeOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((MargrabeOption const *)arg1)->gamma2();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_MargrabeOption(void * jarg1) {
  MargrabeOption *arg1 = (MargrabeOption *) 0 ;
  ext::shared_ptr< MargrabeOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MargrabeOption > *)jarg1;
  arg1 = (MargrabeOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticEuropeanMargrabeEngine(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg2 ;
  Real arg3 ;
  AnalyticEuropeanMargrabeEngine *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  if (jarg2) arg2 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (AnalyticEuropeanMargrabeEngine *)new AnalyticEuropeanMargrabeEngine(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 ? new ext::shared_ptr<  AnalyticEuropeanMargrabeEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticEuropeanMargrabeEngine(void * jarg1) {
  AnalyticEuropeanMargrabeEngine *arg1 = (AnalyticEuropeanMargrabeEngine *) 0 ;
  ext::shared_ptr< AnalyticEuropeanMargrabeEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticEuropeanMargrabeEngine > *)jarg1;
  arg1 = (AnalyticEuropeanMargrabeEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticAmericanMargrabeEngine(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg2 ;
  Real arg3 ;
  AnalyticAmericanMargrabeEngine *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  if (jarg2) arg2 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (AnalyticAmericanMargrabeEngine *)new AnalyticAmericanMargrabeEngine(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 ? new ext::shared_ptr<  AnalyticAmericanMargrabeEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticAmericanMargrabeEngine(void * jarg1) {
  AnalyticAmericanMargrabeEngine *arg1 = (AnalyticAmericanMargrabeEngine *) 0 ;
  ext::shared_ptr< AnalyticAmericanMargrabeEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticAmericanMargrabeEngine > *)jarg1;
  arg1 = (AnalyticAmericanMargrabeEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CompoundOption(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< StrikedTypePayoff > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > arg3 ;
  ext::shared_ptr< Exercise > arg4 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  CompoundOption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  if (jarg3) arg3 = *(ext::shared_ptr< StrikedTypePayoff > *)jarg3; 
  if (jarg4) arg4 = *(ext::shared_ptr< Exercise > *)jarg4; 
  {
    try {
      result = (CompoundOption *)new CompoundOption((ext::shared_ptr< StrikedTypePayoff > const &)*arg1,(ext::shared_ptr< Exercise > 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 ? new ext::shared_ptr<  CompoundOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CompoundOption(void * jarg1) {
  CompoundOption *arg1 = (CompoundOption *) 0 ;
  ext::shared_ptr< CompoundOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CompoundOption > *)jarg1;
  arg1 = (CompoundOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticCompoundOptionEngine(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  AnalyticCompoundOptionEngine *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  {
    try {
      result = (AnalyticCompoundOptionEngine *)new AnalyticCompoundOptionEngine(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticCompoundOptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticCompoundOptionEngine(void * jarg1) {
  AnalyticCompoundOptionEngine *arg1 = (AnalyticCompoundOptionEngine *) 0 ;
  ext::shared_ptr< AnalyticCompoundOptionEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticCompoundOptionEngine > *)jarg1;
  arg1 = (AnalyticCompoundOptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SimpleChooserOption(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Date arg1 ;
  Real arg2 ;
  ext::shared_ptr< Exercise > *arg3 = 0 ;
  Date *argp1 ;
  ext::shared_ptr< Exercise > tempnull3 ;
  SimpleChooserOption *result = 0 ;
  
  argp1 = (Date *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< Exercise > *)jarg3 : &tempnull3; 
  {
    try {
      result = (SimpleChooserOption *)new SimpleChooserOption(arg1,arg2,(ext::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 = result ? new ext::shared_ptr<  SimpleChooserOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SimpleChooserOption(void * jarg1) {
  SimpleChooserOption *arg1 = (SimpleChooserOption *) 0 ;
  ext::shared_ptr< SimpleChooserOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SimpleChooserOption > *)jarg1;
  arg1 = (SimpleChooserOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticSimpleChooserEngine(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  AnalyticSimpleChooserEngine *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  {
    try {
      result = (AnalyticSimpleChooserEngine *)new AnalyticSimpleChooserEngine(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticSimpleChooserEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticSimpleChooserEngine(void * jarg1) {
  AnalyticSimpleChooserEngine *arg1 = (AnalyticSimpleChooserEngine *) 0 ;
  ext::shared_ptr< AnalyticSimpleChooserEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticSimpleChooserEngine > *)jarg1;
  arg1 = (AnalyticSimpleChooserEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ComplexChooserOption(void * jarg1, double jarg2, double jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date arg1 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< Exercise > *arg4 = 0 ;
  ext::shared_ptr< Exercise > *arg5 = 0 ;
  Date *argp1 ;
  ext::shared_ptr< Exercise > tempnull4 ;
  ext::shared_ptr< Exercise > tempnull5 ;
  ComplexChooserOption *result = 0 ;
  
  argp1 = (Date *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< Exercise > *)jarg4 : &tempnull4; 
  arg5 = jarg5 ? (ext::shared_ptr< Exercise > *)jarg5 : &tempnull5; 
  {
    try {
      result = (ComplexChooserOption *)new ComplexChooserOption(arg1,arg2,arg3,(ext::shared_ptr< Exercise > const &)*arg4,(ext::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 = result ? new ext::shared_ptr<  ComplexChooserOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ComplexChooserOption(void * jarg1) {
  ComplexChooserOption *arg1 = (ComplexChooserOption *) 0 ;
  ext::shared_ptr< ComplexChooserOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ComplexChooserOption > *)jarg1;
  arg1 = (ComplexChooserOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticComplexChooserEngine(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  AnalyticComplexChooserEngine *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  {
    try {
      result = (AnalyticComplexChooserEngine *)new AnalyticComplexChooserEngine(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticComplexChooserEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticComplexChooserEngine(void * jarg1) {
  AnalyticComplexChooserEngine *arg1 = (AnalyticComplexChooserEngine *) 0 ;
  ext::shared_ptr< AnalyticComplexChooserEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticComplexChooserEngine > *)jarg1;
  arg1 = (AnalyticComplexChooserEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< StrikedTypePayoff > *arg2 = 0 ;
  ext::shared_ptr< Exercise > *arg3 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull2 ;
  ext::shared_ptr< Exercise > tempnull3 ;
  ContinuousAveragingAsianOption *result = 0 ;
  
  arg1 = (Average::Type)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< Exercise > *)jarg3 : &tempnull3; 
  {
    try {
      result = (ContinuousAveragingAsianOption *)new ContinuousAveragingAsianOption(arg1,(ext::shared_ptr< StrikedTypePayoff > const &)*arg2,(ext::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 = result ? new ext::shared_ptr<  ContinuousAveragingAsianOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ContinuousAveragingAsianOption(void * jarg1) {
  ContinuousAveragingAsianOption *arg1 = (ContinuousAveragingAsianOption *) 0 ;
  ext::shared_ptr< ContinuousAveragingAsianOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ContinuousAveragingAsianOption > *)jarg1;
  arg1 = (ContinuousAveragingAsianOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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__SWIG_0(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 ;
  ext::shared_ptr< StrikedTypePayoff > *arg5 = 0 ;
  ext::shared_ptr< Exercise > *arg6 = 0 ;
  std::vector< Date > *argp4 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull5 ;
  ext::shared_ptr< Exercise > tempnull6 ;
  DiscreteAveragingAsianOption *result = 0 ;
  
  arg1 = (Average::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  argp4 = (std::vector< Date > *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Date >", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = jarg5 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg5 : &tempnull5; 
  arg6 = jarg6 ? (ext::shared_ptr< Exercise > *)jarg6 : &tempnull6; 
  {
    try {
      result = (DiscreteAveragingAsianOption *)new DiscreteAveragingAsianOption(arg1,arg2,arg3,arg4,(ext::shared_ptr< StrikedTypePayoff > const &)*arg5,(ext::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 = result ? new ext::shared_ptr<  DiscreteAveragingAsianOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscreteAveragingAsianOption__SWIG_1(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Average::Type arg1 ;
  std::vector< Date > arg2 ;
  ext::shared_ptr< StrikedTypePayoff > *arg3 = 0 ;
  ext::shared_ptr< Exercise > *arg4 = 0 ;
  std::vector< Real > arg5 ;
  std::vector< Date > *argp2 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull3 ;
  ext::shared_ptr< Exercise > tempnull4 ;
  std::vector< Real > *argp5 ;
  DiscreteAveragingAsianOption *result = 0 ;
  
  arg1 = (Average::Type)jarg1; 
  argp2 = (std::vector< Date > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Date >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< Exercise > *)jarg4 : &tempnull4; 
  argp5 = (std::vector< Real > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg5 = *argp5; 
  {
    try {
      result = (DiscreteAveragingAsianOption *)new DiscreteAveragingAsianOption(arg1,arg2,(ext::shared_ptr< StrikedTypePayoff > const &)*arg3,(ext::shared_ptr< Exercise > 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 ? new ext::shared_ptr<  DiscreteAveragingAsianOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscreteAveragingAsianOption__SWIG_2(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Average::Type arg1 ;
  std::vector< Date > arg2 ;
  ext::shared_ptr< StrikedTypePayoff > *arg3 = 0 ;
  ext::shared_ptr< Exercise > *arg4 = 0 ;
  std::vector< Date > *argp2 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull3 ;
  ext::shared_ptr< Exercise > tempnull4 ;
  DiscreteAveragingAsianOption *result = 0 ;
  
  arg1 = (Average::Type)jarg1; 
  argp2 = (std::vector< Date > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Date >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< Exercise > *)jarg4 : &tempnull4; 
  {
    try {
      result = (DiscreteAveragingAsianOption *)new DiscreteAveragingAsianOption(arg1,arg2,(ext::shared_ptr< StrikedTypePayoff > const &)*arg3,(ext::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 = result ? new ext::shared_ptr<  DiscreteAveragingAsianOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DiscreteAveragingAsianOption_timeGrid(void * jarg1) {
  void * jresult ;
  DiscreteAveragingAsianOption *arg1 = (DiscreteAveragingAsianOption *) 0 ;
  ext::shared_ptr< DiscreteAveragingAsianOption > *smartarg1 = 0 ;
  TimeGrid result;
  
  
  smartarg1 = (ext::shared_ptr<  DiscreteAveragingAsianOption > *)jarg1;
  arg1 = (DiscreteAveragingAsianOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = DiscreteAveragingAsianOption_timeGrid(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new TimeGrid(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DiscreteAveragingAsianOption(void * jarg1) {
  DiscreteAveragingAsianOption *arg1 = (DiscreteAveragingAsianOption *) 0 ;
  ext::shared_ptr< DiscreteAveragingAsianOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DiscreteAveragingAsianOption > *)jarg1;
  arg1 = (DiscreteAveragingAsianOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticContinuousGeometricAveragePriceAsianEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticContinuousGeometricAveragePriceAsianEngine *)new AnalyticContinuousGeometricAveragePriceAsianEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticContinuousGeometricAveragePriceAsianEngine(void * jarg1) {
  AnalyticContinuousGeometricAveragePriceAsianEngine *arg1 = (AnalyticContinuousGeometricAveragePriceAsianEngine *) 0 ;
  ext::shared_ptr< AnalyticContinuousGeometricAveragePriceAsianEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianEngine > *)jarg1;
  arg1 = (AnalyticContinuousGeometricAveragePriceAsianEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine__SWIG_0(void * jarg1, unsigned long jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  AnalyticContinuousGeometricAveragePriceAsianHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (AnalyticContinuousGeometricAveragePriceAsianHestonEngine *)new AnalyticContinuousGeometricAveragePriceAsianHestonEngine((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  AnalyticContinuousGeometricAveragePriceAsianHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (AnalyticContinuousGeometricAveragePriceAsianHestonEngine *)new AnalyticContinuousGeometricAveragePriceAsianHestonEngine((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine__SWIG_2(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  AnalyticContinuousGeometricAveragePriceAsianHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticContinuousGeometricAveragePriceAsianHestonEngine *)new AnalyticContinuousGeometricAveragePriceAsianHestonEngine((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticContinuousGeometricAveragePriceAsianHestonEngine(void * jarg1) {
  AnalyticContinuousGeometricAveragePriceAsianHestonEngine *arg1 = (AnalyticContinuousGeometricAveragePriceAsianHestonEngine *) 0 ;
  ext::shared_ptr< AnalyticContinuousGeometricAveragePriceAsianHestonEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianHestonEngine > *)jarg1;
  arg1 = (AnalyticContinuousGeometricAveragePriceAsianHestonEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticDiscreteGeometricAveragePriceAsianEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticDiscreteGeometricAveragePriceAsianEngine *)new AnalyticDiscreteGeometricAveragePriceAsianEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticDiscreteGeometricAveragePriceAsianEngine(void * jarg1) {
  AnalyticDiscreteGeometricAveragePriceAsianEngine *arg1 = (AnalyticDiscreteGeometricAveragePriceAsianEngine *) 0 ;
  ext::shared_ptr< AnalyticDiscreteGeometricAveragePriceAsianEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianEngine > *)jarg1;
  arg1 = (AnalyticDiscreteGeometricAveragePriceAsianEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine__SWIG_0(void * jarg1, double jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *)new AnalyticDiscreteGeometricAveragePriceAsianHestonEngine((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine__SWIG_1(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *)new AnalyticDiscreteGeometricAveragePriceAsianHestonEngine((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianHestonEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine(void * jarg1) {
  AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *arg1 = (AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *) 0 ;
  ext::shared_ptr< AnalyticDiscreteGeometricAveragePriceAsianHestonEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianHestonEngine > *)jarg1;
  arg1 = (AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticDiscreteGeometricAverageStrikeAsianEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticDiscreteGeometricAverageStrikeAsianEngine *)new AnalyticDiscreteGeometricAverageStrikeAsianEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticDiscreteGeometricAverageStrikeAsianEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticDiscreteGeometricAverageStrikeAsianEngine(void * jarg1) {
  AnalyticDiscreteGeometricAverageStrikeAsianEngine *arg1 = (AnalyticDiscreteGeometricAverageStrikeAsianEngine *) 0 ;
  ext::shared_ptr< AnalyticDiscreteGeometricAverageStrikeAsianEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticDiscreteGeometricAverageStrikeAsianEngine > *)jarg1;
  arg1 = (AnalyticDiscreteGeometricAverageStrikeAsianEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPEngine__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7, long jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  BigInteger arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticAPEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (BigInteger)jarg8; 
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPEngine__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticAPEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPEngine__SWIG_2(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, double jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticAPEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPEngine__SWIG_3(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticAPEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPEngine__SWIG_4(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticAPEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPEngine__SWIG_5(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticAPEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPEngine__SWIG_6(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticAPEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPEngine__SWIG_7(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticAPEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPRDiscreteArithmeticAPEngine(void * jarg1) {
  MCDiscreteArithmeticAPEngine< PseudoRandom > *arg1 = (MCDiscreteArithmeticAPEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCDiscreteArithmeticAPEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCDiscreteArithmeticAPEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCDiscreteArithmeticAPEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPEngine__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7, long jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  BigInteger arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticAPEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (BigInteger)jarg8; 
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPEngine__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, double jarg6, int jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  intOrNull arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticAPEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPEngine__SWIG_2(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, double jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  doubleOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticAPEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPEngine__SWIG_3(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  intOrNull arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticAPEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (intOrNull)jarg5; 
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPEngine__SWIG_4(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticAPEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPEngine__SWIG_5(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticAPEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPEngine__SWIG_6(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticAPEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPEngine__SWIG_7(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticAPEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDDiscreteArithmeticAPEngine(void * jarg1) {
  MCDiscreteArithmeticAPEngine< LowDiscrepancy > *arg1 = (MCDiscreteArithmeticAPEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCDiscreteArithmeticAPEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCDiscreteArithmeticAPEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCDiscreteArithmeticAPEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPHestonEngine__SWIG_0(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5, long jarg6, int jarg7, int jarg8, unsigned int jarg9) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  BigInteger arg6 ;
  intOrNull arg7 ;
  intOrNull arg8 ;
  bool arg9 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (BigInteger)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = jarg9 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPHestonEngine__SWIG_1(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5, long jarg6, int jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  BigInteger arg6 ;
  intOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (BigInteger)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPHestonEngine__SWIG_2(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5, long jarg6, int jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  BigInteger arg6 ;
  intOrNull arg7 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (BigInteger)jarg6; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPHestonEngine__SWIG_3(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5, long jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  BigInteger arg6 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (BigInteger)jarg6; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 = result ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPHestonEngine__SWIG_4(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPHestonEngine__SWIG_5(void * jarg1, unsigned int jarg2, int jarg3, double jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPHestonEngine__SWIG_6(void * jarg1, unsigned int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPHestonEngine__SWIG_7(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticAPHestonEngine__SWIG_8(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPRDiscreteArithmeticAPHestonEngine(void * jarg1) {
  MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *arg1 = (MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCDiscreteArithmeticAPHestonEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCDiscreteArithmeticAPHestonEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPHestonEngine__SWIG_0(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5, long jarg6, int jarg7, int jarg8, unsigned int jarg9) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  BigInteger arg6 ;
  intOrNull arg7 ;
  intOrNull arg8 ;
  bool arg9 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (BigInteger)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = jarg9 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPHestonEngine__SWIG_1(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5, long jarg6, int jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  BigInteger arg6 ;
  intOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (BigInteger)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPHestonEngine__SWIG_2(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5, long jarg6, int jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  BigInteger arg6 ;
  intOrNull arg7 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (BigInteger)jarg6; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPHestonEngine__SWIG_3(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5, long jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  BigInteger arg6 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (BigInteger)jarg6; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 = result ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPHestonEngine__SWIG_4(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPHestonEngine__SWIG_5(void * jarg1, unsigned int jarg2, int jarg3, double jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPHestonEngine__SWIG_6(void * jarg1, unsigned int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPHestonEngine__SWIG_7(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticAPHestonEngine__SWIG_8(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDDiscreteArithmeticAPHestonEngine(void * jarg1) {
  MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *arg1 = (MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticASEngine__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5, int jarg6, long jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  intOrNull arg6 ;
  BigInteger arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticASEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (BigInteger)jarg7; 
  {
    try {
      result = (MCDiscreteArithmeticASEngine< PseudoRandom > *)new_MCDiscreteArithmeticASEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteArithmeticASEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticASEngine__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticASEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCDiscreteArithmeticASEngine< PseudoRandom > *)new_MCDiscreteArithmeticASEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  MCDiscreteArithmeticASEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticASEngine__SWIG_2(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticASEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  {
    try {
      result = (MCDiscreteArithmeticASEngine< PseudoRandom > *)new_MCDiscreteArithmeticASEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticASEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticASEngine__SWIG_3(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticASEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  {
    try {
      result = (MCDiscreteArithmeticASEngine< PseudoRandom > *)new_MCDiscreteArithmeticASEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticASEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticASEngine__SWIG_4(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticASEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticASEngine< PseudoRandom > *)new_MCDiscreteArithmeticASEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticASEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticASEngine__SWIG_5(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticASEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticASEngine< PseudoRandom > *)new_MCDiscreteArithmeticASEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticASEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteArithmeticASEngine__SWIG_6(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticASEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCDiscreteArithmeticASEngine< PseudoRandom > *)new_MCDiscreteArithmeticASEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCDiscreteArithmeticASEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPRDiscreteArithmeticASEngine(void * jarg1) {
  MCDiscreteArithmeticASEngine< PseudoRandom > *arg1 = (MCDiscreteArithmeticASEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCDiscreteArithmeticASEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCDiscreteArithmeticASEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCDiscreteArithmeticASEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticASEngine__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5, int jarg6, long jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  intOrNull arg6 ;
  BigInteger arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticASEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (BigInteger)jarg7; 
  {
    try {
      result = (MCDiscreteArithmeticASEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticASEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteArithmeticASEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticASEngine__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticASEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCDiscreteArithmeticASEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticASEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  MCDiscreteArithmeticASEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticASEngine__SWIG_2(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticASEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  {
    try {
      result = (MCDiscreteArithmeticASEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticASEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticASEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticASEngine__SWIG_3(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticASEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  {
    try {
      result = (MCDiscreteArithmeticASEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticASEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticASEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticASEngine__SWIG_4(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticASEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticASEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticASEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticASEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticASEngine__SWIG_5(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticASEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MCDiscreteArithmeticASEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticASEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteArithmeticASEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteArithmeticASEngine__SWIG_6(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteArithmeticASEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCDiscreteArithmeticASEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticASEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCDiscreteArithmeticASEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDDiscreteArithmeticASEngine(void * jarg1) {
  MCDiscreteArithmeticASEngine< LowDiscrepancy > *arg1 = (MCDiscreteArithmeticASEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCDiscreteArithmeticASEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCDiscreteArithmeticASEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCDiscreteArithmeticASEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteGeometricAPEngine__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5, int jarg6, long jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  intOrNull arg6 ;
  BigInteger arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteGeometricAPEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (BigInteger)jarg7; 
  {
    try {
      result = (MCDiscreteGeometricAPEngine< PseudoRandom > *)new_MCDiscreteGeometricAPEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteGeometricAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteGeometricAPEngine__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteGeometricAPEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCDiscreteGeometricAPEngine< PseudoRandom > *)new_MCDiscreteGeometricAPEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  MCDiscreteGeometricAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteGeometricAPEngine__SWIG_2(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteGeometricAPEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  {
    try {
      result = (MCDiscreteGeometricAPEngine< PseudoRandom > *)new_MCDiscreteGeometricAPEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteGeometricAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteGeometricAPEngine__SWIG_3(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteGeometricAPEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  {
    try {
      result = (MCDiscreteGeometricAPEngine< PseudoRandom > *)new_MCDiscreteGeometricAPEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteGeometricAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteGeometricAPEngine__SWIG_4(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteGeometricAPEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (MCDiscreteGeometricAPEngine< PseudoRandom > *)new_MCDiscreteGeometricAPEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteGeometricAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteGeometricAPEngine__SWIG_5(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteGeometricAPEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MCDiscreteGeometricAPEngine< PseudoRandom > *)new_MCDiscreteGeometricAPEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteGeometricAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteGeometricAPEngine__SWIG_6(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteGeometricAPEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCDiscreteGeometricAPEngine< PseudoRandom > *)new_MCDiscreteGeometricAPEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCDiscreteGeometricAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPRDiscreteGeometricAPEngine(void * jarg1) {
  MCDiscreteGeometricAPEngine< PseudoRandom > *arg1 = (MCDiscreteGeometricAPEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCDiscreteGeometricAPEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCDiscreteGeometricAPEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCDiscreteGeometricAPEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteGeometricAPEngine__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5, int jarg6, long jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  intOrNull arg6 ;
  BigInteger arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteGeometricAPEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (BigInteger)jarg7; 
  {
    try {
      result = (MCDiscreteGeometricAPEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteGeometricAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteGeometricAPEngine__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteGeometricAPEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCDiscreteGeometricAPEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  MCDiscreteGeometricAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteGeometricAPEngine__SWIG_2(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteGeometricAPEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  {
    try {
      result = (MCDiscreteGeometricAPEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteGeometricAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteGeometricAPEngine__SWIG_3(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteGeometricAPEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  {
    try {
      result = (MCDiscreteGeometricAPEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteGeometricAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteGeometricAPEngine__SWIG_4(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteGeometricAPEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (MCDiscreteGeometricAPEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteGeometricAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteGeometricAPEngine__SWIG_5(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteGeometricAPEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MCDiscreteGeometricAPEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCDiscreteGeometricAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteGeometricAPEngine__SWIG_6(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCDiscreteGeometricAPEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCDiscreteGeometricAPEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCDiscreteGeometricAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDDiscreteGeometricAPEngine(void * jarg1) {
  MCDiscreteGeometricAPEngine< LowDiscrepancy > *arg1 = (MCDiscreteGeometricAPEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCDiscreteGeometricAPEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCDiscreteGeometricAPEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCDiscreteGeometricAPEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteGeometricAPHestonEngine__SWIG_0(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5, long jarg6, int jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  BigInteger arg6 ;
  intOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteGeometricAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (BigInteger)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< PseudoRandom > *)new_MCDiscreteGeometricAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteGeometricAPHestonEngine__SWIG_1(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5, long jarg6, int jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  BigInteger arg6 ;
  intOrNull arg7 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteGeometricAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (BigInteger)jarg6; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< PseudoRandom > *)new_MCDiscreteGeometricAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteGeometricAPHestonEngine__SWIG_2(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5, long jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  BigInteger arg6 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteGeometricAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (BigInteger)jarg6; 
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< PseudoRandom > *)new_MCDiscreteGeometricAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 = result ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteGeometricAPHestonEngine__SWIG_3(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteGeometricAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< PseudoRandom > *)new_MCDiscreteGeometricAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteGeometricAPHestonEngine__SWIG_4(void * jarg1, unsigned int jarg2, int jarg3, double jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteGeometricAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< PseudoRandom > *)new_MCDiscreteGeometricAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteGeometricAPHestonEngine__SWIG_5(void * jarg1, unsigned int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteGeometricAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< PseudoRandom > *)new_MCDiscreteGeometricAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteGeometricAPHestonEngine__SWIG_6(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteGeometricAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< PseudoRandom > *)new_MCDiscreteGeometricAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRDiscreteGeometricAPHestonEngine__SWIG_7(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteGeometricAPHestonEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< PseudoRandom > *)new_MCDiscreteGeometricAPHestonEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPRDiscreteGeometricAPHestonEngine(void * jarg1) {
  MCDiscreteGeometricAPHestonEngine< PseudoRandom > *arg1 = (MCDiscreteGeometricAPHestonEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCDiscreteGeometricAPHestonEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCDiscreteGeometricAPHestonEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteGeometricAPHestonEngine__SWIG_0(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5, long jarg6, int jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  BigInteger arg6 ;
  intOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (BigInteger)jarg6; 
  arg7 = (intOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteGeometricAPHestonEngine__SWIG_1(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5, long jarg6, int jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  BigInteger arg6 ;
  intOrNull arg7 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (BigInteger)jarg6; 
  arg7 = (intOrNull)jarg7; 
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*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 ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteGeometricAPHestonEngine__SWIG_2(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5, long jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  BigInteger arg6 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  arg6 = (BigInteger)jarg6; 
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 = result ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteGeometricAPHestonEngine__SWIG_3(void * jarg1, unsigned int jarg2, int jarg3, double jarg4, int jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  intOrNull arg5 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  arg5 = (intOrNull)jarg5; 
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteGeometricAPHestonEngine__SWIG_4(void * jarg1, unsigned int jarg2, int jarg3, double jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  doubleOrNull arg4 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  arg4 = (doubleOrNull)jarg4; 
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteGeometricAPHestonEngine__SWIG_5(void * jarg1, unsigned int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteGeometricAPHestonEngine__SWIG_6(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDDiscreteGeometricAPHestonEngine__SWIG_7(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPHestonEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDDiscreteGeometricAPHestonEngine(void * jarg1) {
  MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *arg1 = (MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCDiscreteGeometricAPHestonEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Date *arg3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ContinuousArithmeticAsianLevyEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ContinuousArithmeticAsianLevyEngine *)new ContinuousArithmeticAsianLevyEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  ContinuousArithmeticAsianLevyEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ContinuousArithmeticAsianLevyEngine(void * jarg1) {
  ContinuousArithmeticAsianLevyEngine *arg1 = (ContinuousArithmeticAsianLevyEngine *) 0 ;
  ext::shared_ptr< ContinuousArithmeticAsianLevyEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ContinuousArithmeticAsianLevyEngine > *)jarg1;
  arg1 = (ContinuousArithmeticAsianLevyEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesAsianEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBlackScholesAsianEngine *)new FdBlackScholesAsianEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesAsianEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdBlackScholesAsianEngine(void * jarg1) {
  FdBlackScholesAsianEngine *arg1 = (FdBlackScholesAsianEngine *) 0 ;
  ext::shared_ptr< FdBlackScholesAsianEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdBlackScholesAsianEngine > *)jarg1;
  arg1 = (FdBlackScholesAsianEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TurnbullWakemanAsianEngine(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  TurnbullWakemanAsianEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (TurnbullWakemanAsianEngine *)new TurnbullWakemanAsianEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  TurnbullWakemanAsianEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TurnbullWakemanAsianEngine(void * jarg1) {
  TurnbullWakemanAsianEngine *arg1 = (TurnbullWakemanAsianEngine *) 0 ;
  ext::shared_ptr< TurnbullWakemanAsianEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  TurnbullWakemanAsianEngine > *)jarg1;
  arg1 = (TurnbullWakemanAsianEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_BarrierOption(int jarg1, double jarg2, double jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Barrier::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< StrikedTypePayoff > *arg4 = 0 ;
  ext::shared_ptr< Exercise > *arg5 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull4 ;
  ext::shared_ptr< Exercise > tempnull5 ;
  BarrierOption *result = 0 ;
  
  arg1 = (Barrier::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg4 : &tempnull4; 
  arg5 = jarg5 ? (ext::shared_ptr< Exercise > *)jarg5 : &tempnull5; 
  {
    try {
      result = (BarrierOption *)new BarrierOption(arg1,arg2,arg3,(ext::shared_ptr< StrikedTypePayoff > const &)*arg4,(ext::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 = result ? new ext::shared_ptr<  BarrierOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  Volatility arg7 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  BarrierOption > *)jarg1;
  arg1 = (BarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Volatility)jarg6; 
  arg7 = (Volatility)jarg7; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  BarrierOption > *)jarg1;
  arg1 = (BarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Volatility)jarg6; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  BarrierOption > *)jarg1;
  arg1 = (BarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  BarrierOption > *)jarg1;
  arg1 = (BarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  BarrierOption > *)jarg1;
  arg1 = (BarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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_impliedVolatility__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, unsigned long jarg6, double jarg7, double jarg8) {
  double jresult ;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  BarrierOption > *)jarg1;
  arg1 = (BarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (DividendSchedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DividendSchedule const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Volatility)jarg7; 
  arg8 = (Volatility)jarg8; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule 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_BarrierOption_impliedVolatility__SWIG_6(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, unsigned long jarg6, double jarg7) {
  double jresult ;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  Volatility arg7 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  BarrierOption > *)jarg1;
  arg1 = (BarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (DividendSchedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DividendSchedule const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Volatility)jarg7; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule 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_BarrierOption_impliedVolatility__SWIG_7(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, unsigned long jarg6) {
  double jresult ;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  BarrierOption > *)jarg1;
  arg1 = (BarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (DividendSchedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DividendSchedule const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule 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_BarrierOption_impliedVolatility__SWIG_8(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5) {
  double jresult ;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  Real arg5 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  BarrierOption > *)jarg1;
  arg1 = (BarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (DividendSchedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DividendSchedule const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule 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_BarrierOption_impliedVolatility__SWIG_9(void * jarg1, double jarg2, void * jarg3, void * jarg4) {
  double jresult ;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  BarrierOption > *)jarg1;
  arg1 = (BarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (DividendSchedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DividendSchedule const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule 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_delete_BarrierOption(void * jarg1) {
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BarrierOption > *)jarg1;
  arg1 = (BarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuantoBarrierOption(int jarg1, double jarg2, double jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Barrier::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< StrikedTypePayoff > *arg4 = 0 ;
  ext::shared_ptr< Exercise > *arg5 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull4 ;
  ext::shared_ptr< Exercise > tempnull5 ;
  QuantoBarrierOption *result = 0 ;
  
  arg1 = (Barrier::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg4 : &tempnull4; 
  arg5 = jarg5 ? (ext::shared_ptr< Exercise > *)jarg5 : &tempnull5; 
  {
    try {
      result = (QuantoBarrierOption *)new QuantoBarrierOption(arg1,arg2,arg3,(ext::shared_ptr< StrikedTypePayoff > const &)*arg4,(ext::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 = result ? new ext::shared_ptr<  QuantoBarrierOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QuantoBarrierOption(void * jarg1) {
  QuantoBarrierOption *arg1 = (QuantoBarrierOption *) 0 ;
  ext::shared_ptr< QuantoBarrierOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  QuantoBarrierOption > *)jarg1;
  arg1 = (QuantoBarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PartialTimeBarrierOption(int jarg1, int jarg2, double jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  PartialBarrier::Type arg1 ;
  PartialBarrier::Range arg2 ;
  Real arg3 ;
  Real arg4 ;
  Date arg5 ;
  ext::shared_ptr< StrikedTypePayoff > *arg6 = 0 ;
  ext::shared_ptr< Exercise > *arg7 = 0 ;
  Date *argp5 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull6 ;
  ext::shared_ptr< Exercise > tempnull7 ;
  PartialTimeBarrierOption *result = 0 ;
  
  arg1 = (PartialBarrier::Type)jarg1; 
  arg2 = (PartialBarrier::Range)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  argp5 = (Date *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg5 = *argp5; 
  arg6 = jarg6 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg6 : &tempnull6; 
  arg7 = jarg7 ? (ext::shared_ptr< Exercise > *)jarg7 : &tempnull7; 
  {
    try {
      result = (PartialTimeBarrierOption *)new PartialTimeBarrierOption(arg1,arg2,arg3,arg4,arg5,(ext::shared_ptr< StrikedTypePayoff > const &)*arg6,(ext::shared_ptr< Exercise > 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 ? new ext::shared_ptr<  PartialTimeBarrierOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PartialTimeBarrierOption(void * jarg1) {
  PartialTimeBarrierOption *arg1 = (PartialTimeBarrierOption *) 0 ;
  ext::shared_ptr< PartialTimeBarrierOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PartialTimeBarrierOption > *)jarg1;
  arg1 = (PartialTimeBarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticPartialTimeBarrierOptionEngine(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticPartialTimeBarrierOptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticPartialTimeBarrierOptionEngine *)new AnalyticPartialTimeBarrierOptionEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticPartialTimeBarrierOptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticPartialTimeBarrierOptionEngine(void * jarg1) {
  AnalyticPartialTimeBarrierOptionEngine *arg1 = (AnalyticPartialTimeBarrierOptionEngine *) 0 ;
  ext::shared_ptr< AnalyticPartialTimeBarrierOptionEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticPartialTimeBarrierOptionEngine > *)jarg1;
  arg1 = (AnalyticPartialTimeBarrierOptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DividendBarrierOption(int jarg1, double jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Barrier::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< StrikedTypePayoff > *arg4 = 0 ;
  ext::shared_ptr< Exercise > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  std::vector< Real > *arg7 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull4 ;
  ext::shared_ptr< Exercise > tempnull5 ;
  DividendBarrierOption *result = 0 ;
  
  arg1 = (Barrier::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg4 : &tempnull4; 
  arg5 = jarg5 ? (ext::shared_ptr< Exercise > *)jarg5 : &tempnull5; 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Real > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DividendBarrierOption *)new DividendBarrierOption(arg1,arg2,arg3,(ext::shared_ptr< StrikedTypePayoff > const &)*arg4,(ext::shared_ptr< Exercise > const &)*arg5,(std::vector< Date > const &)*arg6,(std::vector< Real > 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 ? new ext::shared_ptr<  DividendBarrierOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DividendBarrierOption(void * jarg1) {
  DividendBarrierOption *arg1 = (DividendBarrierOption *) 0 ;
  ext::shared_ptr< DividendBarrierOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DividendBarrierOption > *)jarg1;
  arg1 = (DividendBarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticBarrierEngine *)new AnalyticBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticBarrierEngine(void * jarg1) {
  AnalyticBarrierEngine *arg1 = (AnalyticBarrierEngine *) 0 ;
  ext::shared_ptr< AnalyticBarrierEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticBarrierEngine > *)jarg1;
  arg1 = (AnalyticBarrierEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRBarrierEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, unsigned int jarg9, long jarg10) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  bool arg9 ;
  BigInteger arg10 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = jarg9 ? true : false; 
  arg10 = (BigInteger)jarg10; 
  {
    try {
      result = (MCBarrierEngine< PseudoRandom > *)new_MCBarrierEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,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 = result ? new ext::shared_ptr<  MCBarrierEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRBarrierEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, unsigned int jarg9) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  bool arg9 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = jarg9 ? true : false; 
  {
    try {
      result = (MCBarrierEngine< PseudoRandom > *)new_MCBarrierEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCBarrierEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRBarrierEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCBarrierEngine< PseudoRandom > *)new_MCBarrierEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCBarrierEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRBarrierEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCBarrierEngine< PseudoRandom > *)new_MCBarrierEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCBarrierEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRBarrierEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCBarrierEngine< PseudoRandom > *)new_MCBarrierEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  MCBarrierEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRBarrierEngine__SWIG_5(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCBarrierEngine< PseudoRandom > *)new_MCBarrierEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCBarrierEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRBarrierEngine__SWIG_6(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCBarrierEngine< PseudoRandom > *)new_MCBarrierEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCBarrierEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRBarrierEngine__SWIG_7(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCBarrierEngine< PseudoRandom > *)new_MCBarrierEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCBarrierEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRBarrierEngine__SWIG_8(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCBarrierEngine< PseudoRandom > *)new_MCBarrierEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCBarrierEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRBarrierEngine__SWIG_9(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCBarrierEngine< PseudoRandom > *)new_MCBarrierEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCBarrierEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPRBarrierEngine(void * jarg1) {
  MCBarrierEngine< PseudoRandom > *arg1 = (MCBarrierEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCBarrierEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCBarrierEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCBarrierEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDBarrierEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, unsigned int jarg9, long jarg10) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  bool arg9 ;
  BigInteger arg10 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = jarg9 ? true : false; 
  arg10 = (BigInteger)jarg10; 
  {
    try {
      result = (MCBarrierEngine< LowDiscrepancy > *)new_MCBarrierEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,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 = result ? new ext::shared_ptr<  MCBarrierEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDBarrierEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, unsigned int jarg9) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  bool arg9 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = jarg9 ? true : false; 
  {
    try {
      result = (MCBarrierEngine< LowDiscrepancy > *)new_MCBarrierEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCBarrierEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDBarrierEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCBarrierEngine< LowDiscrepancy > *)new_MCBarrierEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCBarrierEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDBarrierEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCBarrierEngine< LowDiscrepancy > *)new_MCBarrierEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*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 ? new ext::shared_ptr<  MCBarrierEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDBarrierEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCBarrierEngine< LowDiscrepancy > *)new_MCBarrierEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  MCBarrierEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDBarrierEngine__SWIG_5(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCBarrierEngine< LowDiscrepancy > *)new_MCBarrierEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCBarrierEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDBarrierEngine__SWIG_6(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCBarrierEngine< LowDiscrepancy > *)new_MCBarrierEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCBarrierEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDBarrierEngine__SWIG_7(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCBarrierEngine< LowDiscrepancy > *)new_MCBarrierEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCBarrierEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDBarrierEngine__SWIG_8(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCBarrierEngine< LowDiscrepancy > *)new_MCBarrierEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  MCBarrierEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDBarrierEngine__SWIG_9(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  MCBarrierEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCBarrierEngine< LowDiscrepancy > *)new_MCBarrierEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCBarrierEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDBarrierEngine(void * jarg1) {
  MCBarrierEngine< LowDiscrepancy > *arg1 = (MCBarrierEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCBarrierEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCBarrierEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCBarrierEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_QuantoBarrierEngine(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Handle< YieldTermStructure > arg2 ;
  Handle< BlackVolTermStructure > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > *argp2 ;
  Handle< BlackVolTermStructure > *argp3 ;
  Handle< Quote > *argp4 ;
  QuantoBarrierEngine *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  argp2 = (Handle< YieldTermStructure > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg2 = *argp2; 
  argp3 = (Handle< BlackVolTermStructure > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< BlackVolTermStructure >", 0);
    return 0;
  }
  arg3 = *argp3; 
  argp4 = (Handle< Quote > *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg4 = *argp4; 
  {
    try {
      result = (QuantoBarrierEngine *)new QuantoBarrierEngine(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 ? new ext::shared_ptr<  QuantoBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_QuantoBarrierEngine(void * jarg1) {
  QuantoBarrierEngine *arg1 = (QuantoBarrierEngine *) 0 ;
  ext::shared_ptr< QuantoBarrierEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  QuantoBarrierEngine > *)jarg1;
  arg1 = (QuantoBarrierEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  Real arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_3(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_4(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_5(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_6(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_7(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, unsigned int jarg7, double jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  Real arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_8(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, unsigned int jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_9(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_10(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_11(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_12(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesBarrierEngine__SWIG_13(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdBlackScholesBarrierEngine(void * jarg1) {
  FdBlackScholesBarrierEngine *arg1 = (FdBlackScholesBarrierEngine *) 0 ;
  ext::shared_ptr< FdBlackScholesBarrierEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdBlackScholesBarrierEngine > *)jarg1;
  arg1 = (FdBlackScholesBarrierEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesRebateEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, void * jarg5, unsigned int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  Real arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesRebateEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, void * jarg5, unsigned int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesRebateEngine__SWIG_2(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, void * jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesRebateEngine__SWIG_3(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesRebateEngine__SWIG_4(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesRebateEngine__SWIG_5(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesRebateEngine__SWIG_6(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesRebateEngine__SWIG_7(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, unsigned int jarg7, double jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  Real arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesRebateEngine__SWIG_8(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, unsigned int jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesRebateEngine__SWIG_9(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesRebateEngine__SWIG_10(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesRebateEngine__SWIG_11(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesRebateEngine__SWIG_12(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdBlackScholesRebateEngine__SWIG_13(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  DividendSchedule *argp2 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdBlackScholesRebateEngine(void * jarg1) {
  FdBlackScholesRebateEngine *arg1 = (FdBlackScholesRebateEngine *) 0 ;
  ext::shared_ptr< FdBlackScholesRebateEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdBlackScholesRebateEngine > *)jarg1;
  arg1 = (FdBlackScholesRebateEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonBarrierEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, void * jarg7, double jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg7 = 0 ;
  Real arg8 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull7 ;
  FdHestonBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg7 : &tempnull7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonBarrierEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg7 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull7 ;
  FdHestonBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg7 : &tempnull7; 
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonBarrierEngine__SWIG_2(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > 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 = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonBarrierEngine__SWIG_3(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonBarrierEngine__SWIG_4(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonBarrierEngine__SWIG_5(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonBarrierEngine__SWIG_6(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonBarrierEngine__SWIG_7(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonBarrierEngine__SWIG_8(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7, void * jarg8, double jarg9) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = 0 ;
  Real arg9 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull8 ;
  FdHestonBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg8 : &tempnull8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,(ext::shared_ptr< LocalVolTermStructure > 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 = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonBarrierEngine__SWIG_9(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull8 ;
  FdHestonBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg8 : &tempnull8; 
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonBarrierEngine__SWIG_10(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > 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 = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonBarrierEngine__SWIG_11(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > 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 = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonBarrierEngine__SWIG_12(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonBarrierEngine__SWIG_13(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonBarrierEngine__SWIG_14(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonBarrierEngine__SWIG_15(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdHestonBarrierEngine(void * jarg1) {
  FdHestonBarrierEngine *arg1 = (FdHestonBarrierEngine *) 0 ;
  ext::shared_ptr< FdHestonBarrierEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdHestonBarrierEngine > *)jarg1;
  arg1 = (FdHestonBarrierEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonRebateEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, void * jarg7, double jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg7 = 0 ;
  Real arg8 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull7 ;
  FdHestonRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg7 : &tempnull7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonRebateEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg7 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull7 ;
  FdHestonRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg7 : &tempnull7; 
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonRebateEngine__SWIG_2(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > 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 = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonRebateEngine__SWIG_3(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonRebateEngine__SWIG_4(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonRebateEngine__SWIG_5(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonRebateEngine__SWIG_6(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonRebateEngine__SWIG_7(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonRebateEngine__SWIG_8(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7, void * jarg8, double jarg9) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = 0 ;
  Real arg9 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull8 ;
  FdHestonRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg8 : &tempnull8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,(ext::shared_ptr< LocalVolTermStructure > 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 = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonRebateEngine__SWIG_9(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull8 ;
  FdHestonRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg8 : &tempnull8; 
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonRebateEngine__SWIG_10(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, void * jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > 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 = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonRebateEngine__SWIG_11(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > 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 = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonRebateEngine__SWIG_12(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonRebateEngine__SWIG_13(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonRebateEngine__SWIG_14(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonRebateEngine__SWIG_15(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  DividendSchedule *argp2 ;
  FdHestonRebateEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  argp2 = (DividendSchedule *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DividendSchedule", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdHestonRebateEngine(void * jarg1) {
  FdHestonRebateEngine *arg1 = (FdHestonRebateEngine *) 0 ;
  ext::shared_ptr< FdHestonRebateEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdHestonRebateEngine > *)jarg1;
  arg1 = (FdHestonRebateEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticBinaryBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticBinaryBarrierEngine *)new AnalyticBinaryBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticBinaryBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticBinaryBarrierEngine(void * jarg1) {
  AnalyticBinaryBarrierEngine *arg1 = (AnalyticBinaryBarrierEngine *) 0 ;
  ext::shared_ptr< AnalyticBinaryBarrierEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticBinaryBarrierEngine > *)jarg1;
  arg1 = (AnalyticBinaryBarrierEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialCRRBarrierEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialCRRBarrierEngine__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialCRRBarrierEngine(void * jarg1) {
  BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *arg1 = (BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *) 0 ;
  ext::shared_ptr< BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniBarrierOption> > *)jarg1;
  arg1 = (BinomialBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniBarrierOption> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialJRBarrierEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialBarrierEngine<JarrowRudd,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialJRBarrierEngine__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialBarrierEngine<JarrowRudd,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialJRBarrierEngine(void * jarg1) {
  BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *arg1 = (BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *) 0 ;
  ext::shared_ptr< BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialBarrierEngine<JarrowRudd,DiscretizedDermanKaniBarrierOption> > *)jarg1;
  arg1 = (BinomialBarrierEngine<JarrowRudd,DiscretizedDermanKaniBarrierOption> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialEQPBarrierEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialEQPBarrierEngine__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialEQPBarrierEngine(void * jarg1) {
  BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > *arg1 = (BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > *) 0 ;
  ext::shared_ptr< BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption> > *)jarg1;
  arg1 = (BinomialBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialTrigeorgisBarrierEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialBarrierEngine<Trigeorgis,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialTrigeorgisBarrierEngine__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialBarrierEngine<Trigeorgis,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialTrigeorgisBarrierEngine(void * jarg1) {
  BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > *arg1 = (BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > *) 0 ;
  ext::shared_ptr< BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialBarrierEngine<Trigeorgis,DiscretizedDermanKaniBarrierOption> > *)jarg1;
  arg1 = (BinomialBarrierEngine<Trigeorgis,DiscretizedDermanKaniBarrierOption> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialTianBarrierEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialBarrierEngine<Tian,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialTianBarrierEngine__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialBarrierEngine<Tian,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialTianBarrierEngine(void * jarg1) {
  BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > *arg1 = (BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > *) 0 ;
  ext::shared_ptr< BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialBarrierEngine<Tian,DiscretizedDermanKaniBarrierOption> > *)jarg1;
  arg1 = (BinomialBarrierEngine<Tian,DiscretizedDermanKaniBarrierOption> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialLRBarrierEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialBarrierEngine<LeisenReimer,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialLRBarrierEngine__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialBarrierEngine<LeisenReimer,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialLRBarrierEngine(void * jarg1) {
  BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *arg1 = (BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *) 0 ;
  ext::shared_ptr< BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialBarrierEngine<LeisenReimer,DiscretizedDermanKaniBarrierOption> > *)jarg1;
  arg1 = (BinomialBarrierEngine<LeisenReimer,DiscretizedDermanKaniBarrierOption> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialJ4BarrierEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialBarrierEngine<Joshi4,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialJ4BarrierEngine__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialBarrierEngine<Joshi4,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialJ4BarrierEngine(void * jarg1) {
  BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > *arg1 = (BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > *) 0 ;
  ext::shared_ptr< BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialBarrierEngine<Joshi4,DiscretizedDermanKaniBarrierOption> > *)jarg1;
  arg1 = (BinomialBarrierEngine<Joshi4,DiscretizedDermanKaniBarrierOption> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VannaVolgaBarrierEngine__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, unsigned int jarg7, double jarg8) {
  void * jresult ;
  Handle< DeltaVolQuote > *arg1 = 0 ;
  Handle< DeltaVolQuote > *arg2 = 0 ;
  Handle< DeltaVolQuote > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  bool arg7 ;
  Real arg8 ;
  VannaVolgaBarrierEngine *result = 0 ;
  
  arg1 = (Handle< DeltaVolQuote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DeltaVolQuote > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< DeltaVolQuote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DeltaVolQuote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< DeltaVolQuote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DeltaVolQuote > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (VannaVolgaBarrierEngine *)new VannaVolgaBarrierEngine((Handle< DeltaVolQuote > const &)*arg1,(Handle< DeltaVolQuote > const &)*arg2,(Handle< DeltaVolQuote > const &)*arg3,(Handle< Quote > const &)*arg4,(Handle< YieldTermStructure > const &)*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 = result ? new ext::shared_ptr<  VannaVolgaBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VannaVolgaBarrierEngine__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, unsigned int jarg7) {
  void * jresult ;
  Handle< DeltaVolQuote > *arg1 = 0 ;
  Handle< DeltaVolQuote > *arg2 = 0 ;
  Handle< DeltaVolQuote > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  bool arg7 ;
  VannaVolgaBarrierEngine *result = 0 ;
  
  arg1 = (Handle< DeltaVolQuote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DeltaVolQuote > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< DeltaVolQuote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DeltaVolQuote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< DeltaVolQuote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DeltaVolQuote > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (VannaVolgaBarrierEngine *)new VannaVolgaBarrierEngine((Handle< DeltaVolQuote > const &)*arg1,(Handle< DeltaVolQuote > const &)*arg2,(Handle< DeltaVolQuote > const &)*arg3,(Handle< Quote > const &)*arg4,(Handle< YieldTermStructure > const &)*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 = result ? new ext::shared_ptr<  VannaVolgaBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VannaVolgaBarrierEngine__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Handle< DeltaVolQuote > *arg1 = 0 ;
  Handle< DeltaVolQuote > *arg2 = 0 ;
  Handle< DeltaVolQuote > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  VannaVolgaBarrierEngine *result = 0 ;
  
  arg1 = (Handle< DeltaVolQuote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DeltaVolQuote > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< DeltaVolQuote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DeltaVolQuote > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< DeltaVolQuote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DeltaVolQuote > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (VannaVolgaBarrierEngine *)new VannaVolgaBarrierEngine((Handle< DeltaVolQuote > const &)*arg1,(Handle< DeltaVolQuote > const &)*arg2,(Handle< DeltaVolQuote > const &)*arg3,(Handle< Quote > const &)*arg4,(Handle< YieldTermStructure > 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 = result ? new ext::shared_ptr<  VannaVolgaBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_VannaVolgaBarrierEngine(void * jarg1) {
  VannaVolgaBarrierEngine *arg1 = (VannaVolgaBarrierEngine *) 0 ;
  ext::shared_ptr< VannaVolgaBarrierEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  VannaVolgaBarrierEngine > *)jarg1;
  arg1 = (VannaVolgaBarrierEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_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 ;
  ext::shared_ptr< StrikedTypePayoff > *arg5 = 0 ;
  ext::shared_ptr< Exercise > *arg6 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull5 ;
  ext::shared_ptr< Exercise > tempnull6 ;
  DoubleBarrierOption *result = 0 ;
  
  arg1 = (DoubleBarrier::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg5 : &tempnull5; 
  arg6 = jarg6 ? (ext::shared_ptr< Exercise > *)jarg6 : &tempnull6; 
  {
    try {
      result = (DoubleBarrierOption *)new DoubleBarrierOption(arg1,arg2,arg3,arg4,(ext::shared_ptr< StrikedTypePayoff > const &)*arg5,(ext::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 = result ? new ext::shared_ptr<  DoubleBarrierOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DoubleBarrierOption(void * jarg1) {
  DoubleBarrierOption *arg1 = (DoubleBarrierOption *) 0 ;
  ext::shared_ptr< DoubleBarrierOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DoubleBarrierOption > *)jarg1;
  arg1 = (DoubleBarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< StrikedTypePayoff > *arg5 = 0 ;
  ext::shared_ptr< Exercise > *arg6 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull5 ;
  ext::shared_ptr< Exercise > tempnull6 ;
  QuantoDoubleBarrierOption *result = 0 ;
  
  arg1 = (DoubleBarrier::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg5 : &tempnull5; 
  arg6 = jarg6 ? (ext::shared_ptr< Exercise > *)jarg6 : &tempnull6; 
  {
    try {
      result = (QuantoDoubleBarrierOption *)new QuantoDoubleBarrierOption(arg1,arg2,arg3,arg4,(ext::shared_ptr< StrikedTypePayoff > const &)*arg5,(ext::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 = result ? new ext::shared_ptr<  QuantoDoubleBarrierOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_QuantoDoubleBarrierOption_qvega(void * jarg1) {
  double jresult ;
  QuantoDoubleBarrierOption *arg1 = (QuantoDoubleBarrierOption *) 0 ;
  ext::shared_ptr< QuantoDoubleBarrierOption > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  QuantoDoubleBarrierOption > *)jarg1;
  arg1 = (QuantoDoubleBarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->qvega();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  QuantoDoubleBarrierOption *arg1 = (QuantoDoubleBarrierOption *) 0 ;
  ext::shared_ptr< QuantoDoubleBarrierOption > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  QuantoDoubleBarrierOption > *)jarg1;
  arg1 = (QuantoDoubleBarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->qrho();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  QuantoDoubleBarrierOption *arg1 = (QuantoDoubleBarrierOption *) 0 ;
  ext::shared_ptr< QuantoDoubleBarrierOption > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  QuantoDoubleBarrierOption > *)jarg1;
  arg1 = (QuantoDoubleBarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->qlambda();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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) {
  QuantoDoubleBarrierOption *arg1 = (QuantoDoubleBarrierOption *) 0 ;
  ext::shared_ptr< QuantoDoubleBarrierOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  QuantoDoubleBarrierOption > *)jarg1;
  arg1 = (QuantoDoubleBarrierOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticDoubleBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (AnalyticDoubleBarrierEngine *)new AnalyticDoubleBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  AnalyticDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticDoubleBarrierEngine__SWIG_1(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticDoubleBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticDoubleBarrierEngine *)new AnalyticDoubleBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticDoubleBarrierEngine(void * jarg1) {
  AnalyticDoubleBarrierEngine *arg1 = (AnalyticDoubleBarrierEngine *) 0 ;
  ext::shared_ptr< AnalyticDoubleBarrierEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticDoubleBarrierEngine > *)jarg1;
  arg1 = (AnalyticDoubleBarrierEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonDoubleBarrierEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, void * jarg7, double jarg8) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg7 = 0 ;
  Real arg8 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull7 ;
  FdHestonDoubleBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg7 : &tempnull7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (FdHestonDoubleBarrierEngine *)new FdHestonDoubleBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdHestonDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonDoubleBarrierEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg7 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull7 ;
  FdHestonDoubleBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg7 : &tempnull7; 
  {
    try {
      result = (FdHestonDoubleBarrierEngine *)new FdHestonDoubleBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdHestonDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonDoubleBarrierEngine__SWIG_2(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonDoubleBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdHestonDoubleBarrierEngine *)new FdHestonDoubleBarrierEngine((ext::shared_ptr< HestonModel > 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 = result ? new ext::shared_ptr<  FdHestonDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonDoubleBarrierEngine__SWIG_3(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonDoubleBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdHestonDoubleBarrierEngine *)new FdHestonDoubleBarrierEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonDoubleBarrierEngine__SWIG_4(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonDoubleBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdHestonDoubleBarrierEngine *)new FdHestonDoubleBarrierEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonDoubleBarrierEngine__SWIG_5(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonDoubleBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdHestonDoubleBarrierEngine *)new FdHestonDoubleBarrierEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonDoubleBarrierEngine__SWIG_6(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonDoubleBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdHestonDoubleBarrierEngine *)new FdHestonDoubleBarrierEngine((ext::shared_ptr< HestonModel > 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 ? new ext::shared_ptr<  FdHestonDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHestonDoubleBarrierEngine__SWIG_7(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > tempnull1 ;
  FdHestonDoubleBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (FdHestonDoubleBarrierEngine *)new FdHestonDoubleBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdHestonDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdHestonDoubleBarrierEngine(void * jarg1) {
  FdHestonDoubleBarrierEngine *arg1 = (FdHestonDoubleBarrierEngine *) 0 ;
  ext::shared_ptr< FdHestonDoubleBarrierEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdHestonDoubleBarrierEngine > *)jarg1;
  arg1 = (FdHestonDoubleBarrierEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SuoWangDoubleBarrierEngine__SWIG_0(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  SuoWangDoubleBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (SuoWangDoubleBarrierEngine *)new SuoWangDoubleBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  SuoWangDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SuoWangDoubleBarrierEngine__SWIG_1(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  SuoWangDoubleBarrierEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (SuoWangDoubleBarrierEngine *)new SuoWangDoubleBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  SuoWangDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SuoWangDoubleBarrierEngine(void * jarg1) {
  SuoWangDoubleBarrierEngine *arg1 = (SuoWangDoubleBarrierEngine *) 0 ;
  ext::shared_ptr< SuoWangDoubleBarrierEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SuoWangDoubleBarrierEngine > *)jarg1;
  arg1 = (SuoWangDoubleBarrierEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VannaVolgaIKDoubleBarrierEngine__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, unsigned int jarg7, double jarg8, int jarg9) {
  void * jresult ;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  bool arg7 ;
  Real arg8 ;
  int 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 ;
  VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *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; 
  arg7 = jarg7 ? true : false; 
  arg8 = (Real)jarg8; 
  arg9 = (int)jarg9; 
  {
    try {
      result = (VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine >(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 ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VannaVolgaIKDoubleBarrierEngine__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, unsigned int jarg7, double jarg8) {
  void * jresult ;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  bool arg7 ;
  Real 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 ;
  VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *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; 
  arg7 = jarg7 ? true : false; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine >(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 ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VannaVolgaIKDoubleBarrierEngine__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, unsigned int jarg7) {
  void * jresult ;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  bool arg7 ;
  Handle< DeltaVolQuote > const *argp1 ;
  Handle< DeltaVolQuote > const *argp2 ;
  Handle< DeltaVolQuote > const *argp3 ;
  Handle< Quote > const *argp4 ;
  Handle< YieldTermStructure > const *argp5 ;
  Handle< YieldTermStructure > const *argp6 ;
  VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *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; 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine >(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 ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VannaVolgaIKDoubleBarrierEngine__SWIG_3(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 ;
  VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *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 = (VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine >(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 ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_VannaVolgaIKDoubleBarrierEngine(void * jarg1) {
  VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *arg1 = (VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *) 0 ;
  ext::shared_ptr< VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> > *)jarg1;
  arg1 = (VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VannaVolgaWODoubleBarrierEngine__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, unsigned int jarg7, double jarg8, int jarg9) {
  void * jresult ;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  bool arg7 ;
  Real arg8 ;
  int 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 ;
  VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *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; 
  arg7 = jarg7 ? true : false; 
  arg8 = (Real)jarg8; 
  arg9 = (int)jarg9; 
  {
    try {
      result = (VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine >(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 ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VannaVolgaWODoubleBarrierEngine__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, unsigned int jarg7, double jarg8) {
  void * jresult ;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  bool arg7 ;
  Real 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 ;
  VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *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; 
  arg7 = jarg7 ? true : false; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine >(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 ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VannaVolgaWODoubleBarrierEngine__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, unsigned int jarg7) {
  void * jresult ;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  bool arg7 ;
  Handle< DeltaVolQuote > const *argp1 ;
  Handle< DeltaVolQuote > const *argp2 ;
  Handle< DeltaVolQuote > const *argp3 ;
  Handle< Quote > const *argp4 ;
  Handle< YieldTermStructure > const *argp5 ;
  Handle< YieldTermStructure > const *argp6 ;
  VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *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; 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine >(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 ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VannaVolgaWODoubleBarrierEngine__SWIG_3(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 ;
  VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *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 = (VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine >(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 ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_VannaVolgaWODoubleBarrierEngine(void * jarg1) {
  VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *arg1 = (VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *) 0 ;
  ext::shared_ptr< VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> > *)jarg1;
  arg1 = (VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticDoubleBarrierBinaryEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticDoubleBarrierBinaryEngine *)new AnalyticDoubleBarrierBinaryEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticDoubleBarrierBinaryEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticDoubleBarrierBinaryEngine(void * jarg1) {
  AnalyticDoubleBarrierBinaryEngine *arg1 = (AnalyticDoubleBarrierBinaryEngine *) 0 ;
  ext::shared_ptr< AnalyticDoubleBarrierBinaryEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticDoubleBarrierBinaryEngine > *)jarg1;
  arg1 = (AnalyticDoubleBarrierBinaryEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialCRRDoubleBarrierEngine(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > *)new BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialDoubleBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialCRRDoubleBarrierEngine(void * jarg1) {
  BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > *arg1 = (BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > *) 0 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialDoubleBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption> > *)jarg1;
  arg1 = (BinomialDoubleBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialJRDoubleBarrierEngine(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > *)new BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialDoubleBarrierEngine<JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialJRDoubleBarrierEngine(void * jarg1) {
  BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > *arg1 = (BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > *) 0 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialDoubleBarrierEngine<JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption> > *)jarg1;
  arg1 = (BinomialDoubleBarrierEngine<JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialEQPDoubleBarrierEngine(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > *)new BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialDoubleBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialEQPDoubleBarrierEngine(void * jarg1) {
  BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > *arg1 = (BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > *) 0 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialDoubleBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption> > *)jarg1;
  arg1 = (BinomialDoubleBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialTrigeorgisDoubleBarrierEngine(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > *)new BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialDoubleBarrierEngine<Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialTrigeorgisDoubleBarrierEngine(void * jarg1) {
  BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > *arg1 = (BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > *) 0 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialDoubleBarrierEngine<Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption> > *)jarg1;
  arg1 = (BinomialDoubleBarrierEngine<Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialTianDoubleBarrierEngine(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > *)new BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialDoubleBarrierEngine<Tian,DiscretizedDermanKaniDoubleBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialTianDoubleBarrierEngine(void * jarg1) {
  BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > *arg1 = (BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > *) 0 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialDoubleBarrierEngine<Tian,DiscretizedDermanKaniDoubleBarrierOption> > *)jarg1;
  arg1 = (BinomialDoubleBarrierEngine<Tian,DiscretizedDermanKaniDoubleBarrierOption> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialLRDoubleBarrierEngine(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > *)new BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialDoubleBarrierEngine<LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialLRDoubleBarrierEngine(void * jarg1) {
  BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > *arg1 = (BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > *) 0 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialDoubleBarrierEngine<LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption> > *)jarg1;
  arg1 = (BinomialDoubleBarrierEngine<LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialJ4DoubleBarrierEngine(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > *)new BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  BinomialDoubleBarrierEngine<Joshi4,DiscretizedDermanKaniDoubleBarrierOption> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialJ4DoubleBarrierEngine(void * jarg1) {
  BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > *arg1 = (BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > *) 0 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialDoubleBarrierEngine<Joshi4,DiscretizedDermanKaniDoubleBarrierOption> > *)jarg1;
  arg1 = (BinomialDoubleBarrierEngine<Joshi4,DiscretizedDermanKaniDoubleBarrierOption> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  PlainVanillaPayoff *result = 0 ;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (PlainVanillaPayoff *)new PlainVanillaPayoff(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 ? new ext::shared_ptr<  PlainVanillaPayoff >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PlainVanillaPayoff(void * jarg1) {
  PlainVanillaPayoff *arg1 = (PlainVanillaPayoff *) 0 ;
  ext::shared_ptr< PlainVanillaPayoff > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PlainVanillaPayoff > *)jarg1;
  arg1 = (PlainVanillaPayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_plain_vanilla_payoff(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< Payoff > *arg1 = 0 ;
  ext::shared_ptr< Payoff > tempnull1 ;
  ext::shared_ptr< PlainVanillaPayoff > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< Payoff > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_plain_vanilla_payoff((ext::shared_ptr< Payoff > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< PlainVanillaPayoff >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PercentageStrikePayoff(int jarg1, double jarg2) {
  void * jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  PercentageStrikePayoff *result = 0 ;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (PercentageStrikePayoff *)new PercentageStrikePayoff(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 ? new ext::shared_ptr<  PercentageStrikePayoff >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PercentageStrikePayoff(void * jarg1) {
  PercentageStrikePayoff *arg1 = (PercentageStrikePayoff *) 0 ;
  ext::shared_ptr< PercentageStrikePayoff > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PercentageStrikePayoff > *)jarg1;
  arg1 = (PercentageStrikePayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  CashOrNothingPayoff *result = 0 ;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (CashOrNothingPayoff *)new CashOrNothingPayoff(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 ? new ext::shared_ptr<  CashOrNothingPayoff >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CashOrNothingPayoff(void * jarg1) {
  CashOrNothingPayoff *arg1 = (CashOrNothingPayoff *) 0 ;
  ext::shared_ptr< CashOrNothingPayoff > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CashOrNothingPayoff > *)jarg1;
  arg1 = (CashOrNothingPayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  AssetOrNothingPayoff *result = 0 ;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (AssetOrNothingPayoff *)new AssetOrNothingPayoff(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 ? new ext::shared_ptr<  AssetOrNothingPayoff >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AssetOrNothingPayoff(void * jarg1) {
  AssetOrNothingPayoff *arg1 = (AssetOrNothingPayoff *) 0 ;
  ext::shared_ptr< AssetOrNothingPayoff > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AssetOrNothingPayoff > *)jarg1;
  arg1 = (AssetOrNothingPayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  SuperSharePayoff *result = 0 ;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (SuperSharePayoff *)new SuperSharePayoff(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 ? new ext::shared_ptr<  SuperSharePayoff >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SuperSharePayoff(void * jarg1) {
  SuperSharePayoff *arg1 = (SuperSharePayoff *) 0 ;
  ext::shared_ptr< SuperSharePayoff > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SuperSharePayoff > *)jarg1;
  arg1 = (SuperSharePayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  GapPayoff *result = 0 ;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (GapPayoff *)new GapPayoff(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 ? new ext::shared_ptr<  GapPayoff >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GapPayoff(void * jarg1) {
  GapPayoff *arg1 = (GapPayoff *) 0 ;
  ext::shared_ptr< GapPayoff > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GapPayoff > *)jarg1;
  arg1 = (GapPayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VanillaForwardPayoff(int jarg1, double jarg2) {
  void * jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  VanillaForwardPayoff *result = 0 ;
  
  arg1 = (Option::Type)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (VanillaForwardPayoff *)new VanillaForwardPayoff(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 ? new ext::shared_ptr<  VanillaForwardPayoff >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_VanillaForwardPayoff(void * jarg1) {
  VanillaForwardPayoff *arg1 = (VanillaForwardPayoff *) 0 ;
  ext::shared_ptr< VanillaForwardPayoff > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaForwardPayoff > *)jarg1;
  arg1 = (VanillaForwardPayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_BasketPayoff(void * jarg1) {
  BasketPayoff *arg1 = (BasketPayoff *) 0 ;
  ext::shared_ptr< BasketPayoff > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BasketPayoff > *)jarg1;
  arg1 = (BasketPayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< Payoff > arg1 ;
  MinBasketPayoff *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< Payoff > *)jarg1; 
  {
    try {
      result = (MinBasketPayoff *)new MinBasketPayoff(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MinBasketPayoff >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MinBasketPayoff(void * jarg1) {
  MinBasketPayoff *arg1 = (MinBasketPayoff *) 0 ;
  ext::shared_ptr< MinBasketPayoff > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MinBasketPayoff > *)jarg1;
  arg1 = (MinBasketPayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< Payoff > arg1 ;
  MaxBasketPayoff *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< Payoff > *)jarg1; 
  {
    try {
      result = (MaxBasketPayoff *)new MaxBasketPayoff(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MaxBasketPayoff >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MaxBasketPayoff(void * jarg1) {
  MaxBasketPayoff *arg1 = (MaxBasketPayoff *) 0 ;
  ext::shared_ptr< MaxBasketPayoff > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MaxBasketPayoff > *)jarg1;
  arg1 = (MaxBasketPayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< Payoff > arg1 ;
  Array *arg2 = 0 ;
  AverageBasketPayoff *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< Payoff > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AverageBasketPayoff *)new AverageBasketPayoff(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 = result ? new ext::shared_ptr<  AverageBasketPayoff >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AverageBasketPayoff__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< Payoff > arg1 ;
  Size arg2 ;
  AverageBasketPayoff *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< Payoff > *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (AverageBasketPayoff *)new AverageBasketPayoff(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 ? new ext::shared_ptr<  AverageBasketPayoff >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AverageBasketPayoff(void * jarg1) {
  AverageBasketPayoff *arg1 = (AverageBasketPayoff *) 0 ;
  ext::shared_ptr< AverageBasketPayoff > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AverageBasketPayoff > *)jarg1;
  arg1 = (AverageBasketPayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadBasketPayoff(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< Payoff > arg1 ;
  SpreadBasketPayoff *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< Payoff > *)jarg1; 
  {
    try {
      result = (SpreadBasketPayoff *)new SpreadBasketPayoff(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  SpreadBasketPayoff >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SpreadBasketPayoff(void * jarg1) {
  SpreadBasketPayoff *arg1 = (SpreadBasketPayoff *) 0 ;
  ext::shared_ptr< SpreadBasketPayoff > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SpreadBasketPayoff > *)jarg1;
  arg1 = (SpreadBasketPayoff *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< BasketPayoff > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  ext::shared_ptr< BasketPayoff > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  BasketOption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BasketPayoff > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  {
    try {
      result = (BasketOption *)new BasketOption((ext::shared_ptr< BasketPayoff > const &)*arg1,(ext::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 = result ? new ext::shared_ptr<  BasketOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BasketOption(void * jarg1) {
  BasketOption *arg1 = (BasketOption *) 0 ;
  ext::shared_ptr< BasketOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BasketOption > *)jarg1;
  arg1 = (BasketOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanBasketEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  {
    try {
      result = (MCEuropeanBasketEngine< PseudoRandom > *)new_MCEuropeanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*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 ? new ext::shared_ptr<  MCEuropeanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanBasketEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCEuropeanBasketEngine< PseudoRandom > *)new_MCEuropeanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*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 ? new ext::shared_ptr<  MCEuropeanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanBasketEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCEuropeanBasketEngine< PseudoRandom > *)new_MCEuropeanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*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 ? new ext::shared_ptr<  MCEuropeanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanBasketEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCEuropeanBasketEngine< PseudoRandom > *)new_MCEuropeanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 = result ? new ext::shared_ptr<  MCEuropeanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanBasketEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCEuropeanBasketEngine< PseudoRandom > *)new_MCEuropeanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCEuropeanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanBasketEngine__SWIG_5(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCEuropeanBasketEngine< PseudoRandom > *)new_MCEuropeanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCEuropeanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanBasketEngine__SWIG_6(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCEuropeanBasketEngine< PseudoRandom > *)new_MCEuropeanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCEuropeanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanBasketEngine__SWIG_7(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCEuropeanBasketEngine< PseudoRandom > *)new_MCEuropeanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCEuropeanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREuropeanBasketEngine__SWIG_8(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCEuropeanBasketEngine< PseudoRandom > *)new_MCEuropeanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCEuropeanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPREuropeanBasketEngine(void * jarg1) {
  MCEuropeanBasketEngine< PseudoRandom > *arg1 = (MCEuropeanBasketEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCEuropeanBasketEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCEuropeanBasketEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCEuropeanBasketEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanBasketEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  {
    try {
      result = (MCEuropeanBasketEngine< LowDiscrepancy > *)new_MCEuropeanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*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 ? new ext::shared_ptr<  MCEuropeanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanBasketEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCEuropeanBasketEngine< LowDiscrepancy > *)new_MCEuropeanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*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 ? new ext::shared_ptr<  MCEuropeanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanBasketEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCEuropeanBasketEngine< LowDiscrepancy > *)new_MCEuropeanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*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 ? new ext::shared_ptr<  MCEuropeanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanBasketEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCEuropeanBasketEngine< LowDiscrepancy > *)new_MCEuropeanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 = result ? new ext::shared_ptr<  MCEuropeanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanBasketEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCEuropeanBasketEngine< LowDiscrepancy > *)new_MCEuropeanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCEuropeanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanBasketEngine__SWIG_5(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCEuropeanBasketEngine< LowDiscrepancy > *)new_MCEuropeanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCEuropeanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanBasketEngine__SWIG_6(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCEuropeanBasketEngine< LowDiscrepancy > *)new_MCEuropeanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCEuropeanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanBasketEngine__SWIG_7(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCEuropeanBasketEngine< LowDiscrepancy > *)new_MCEuropeanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCEuropeanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEuropeanBasketEngine__SWIG_8(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEuropeanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCEuropeanBasketEngine< LowDiscrepancy > *)new_MCEuropeanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCEuropeanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDEuropeanBasketEngine(void * jarg1) {
  MCEuropeanBasketEngine< LowDiscrepancy > *arg1 = (MCEuropeanBasketEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCEuropeanBasketEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCEuropeanBasketEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCEuropeanBasketEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanBasketEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9, unsigned long jarg10, unsigned long jarg11, int jarg12) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  Size arg10 ;
  Size arg11 ;
  LsmBasisSystem::PolynomialType arg12 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  arg10 = (Size)jarg10; 
  arg11 = (Size)jarg11; 
  arg12 = (LsmBasisSystem::PolynomialType)jarg12; 
  {
    try {
      result = (MCAmericanBasketEngine< PseudoRandom > *)new_MCAmericanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,SWIG_STD_MOVE(arg10),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanBasketEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9, unsigned long jarg10, unsigned long jarg11) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  Size arg10 ;
  Size arg11 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  arg10 = (Size)jarg10; 
  arg11 = (Size)jarg11; 
  {
    try {
      result = (MCAmericanBasketEngine< PseudoRandom > *)new_MCAmericanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,SWIG_STD_MOVE(arg10),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanBasketEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9, unsigned long jarg10) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  Size arg10 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  arg10 = (Size)jarg10; 
  {
    try {
      result = (MCAmericanBasketEngine< PseudoRandom > *)new_MCAmericanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanBasketEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  {
    try {
      result = (MCAmericanBasketEngine< PseudoRandom > *)new_MCAmericanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*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 ? new ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanBasketEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCAmericanBasketEngine< PseudoRandom > *)new_MCAmericanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*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 ? new ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanBasketEngine__SWIG_5(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCAmericanBasketEngine< PseudoRandom > *)new_MCAmericanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*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 ? new ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanBasketEngine__SWIG_6(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCAmericanBasketEngine< PseudoRandom > *)new_MCAmericanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 = result ? new ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanBasketEngine__SWIG_7(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCAmericanBasketEngine< PseudoRandom > *)new_MCAmericanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanBasketEngine__SWIG_8(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCAmericanBasketEngine< PseudoRandom > *)new_MCAmericanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanBasketEngine__SWIG_9(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCAmericanBasketEngine< PseudoRandom > *)new_MCAmericanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanBasketEngine__SWIG_10(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCAmericanBasketEngine< PseudoRandom > *)new_MCAmericanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRAmericanBasketEngine__SWIG_11(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCAmericanBasketEngine< PseudoRandom > *)new_MCAmericanBasketEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPRAmericanBasketEngine(void * jarg1) {
  MCAmericanBasketEngine< PseudoRandom > *arg1 = (MCAmericanBasketEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCAmericanBasketEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCAmericanBasketEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanBasketEngine__SWIG_0(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9, unsigned long jarg10, unsigned long jarg11, int jarg12) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  Size arg10 ;
  Size arg11 ;
  LsmBasisSystem::PolynomialType arg12 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  arg10 = (Size)jarg10; 
  arg11 = (Size)jarg11; 
  arg12 = (LsmBasisSystem::PolynomialType)jarg12; 
  {
    try {
      result = (MCAmericanBasketEngine< LowDiscrepancy > *)new_MCAmericanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,SWIG_STD_MOVE(arg10),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanBasketEngine__SWIG_1(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9, unsigned long jarg10, unsigned long jarg11) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  Size arg10 ;
  Size arg11 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  arg10 = (Size)jarg10; 
  arg11 = (Size)jarg11; 
  {
    try {
      result = (MCAmericanBasketEngine< LowDiscrepancy > *)new_MCAmericanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,SWIG_STD_MOVE(arg10),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanBasketEngine__SWIG_2(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9, unsigned long jarg10) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  Size arg10 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  arg10 = (Size)jarg10; 
  {
    try {
      result = (MCAmericanBasketEngine< LowDiscrepancy > *)new_MCAmericanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanBasketEngine__SWIG_3(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  {
    try {
      result = (MCAmericanBasketEngine< LowDiscrepancy > *)new_MCAmericanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*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 ? new ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanBasketEngine__SWIG_4(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCAmericanBasketEngine< LowDiscrepancy > *)new_MCAmericanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*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 ? new ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanBasketEngine__SWIG_5(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCAmericanBasketEngine< LowDiscrepancy > *)new_MCAmericanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*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 ? new ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanBasketEngine__SWIG_6(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCAmericanBasketEngine< LowDiscrepancy > *)new_MCAmericanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 = result ? new ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanBasketEngine__SWIG_7(void * jarg1, int jarg2, int jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCAmericanBasketEngine< LowDiscrepancy > *)new_MCAmericanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanBasketEngine__SWIG_8(void * jarg1, int jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  bool arg4 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCAmericanBasketEngine< LowDiscrepancy > *)new_MCAmericanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanBasketEngine__SWIG_9(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  intOrNull arg3 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  arg3 = (intOrNull)jarg3; 
  {
    try {
      result = (MCAmericanBasketEngine< LowDiscrepancy > *)new_MCAmericanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanBasketEngine__SWIG_10(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (intOrNull)jarg2; 
  {
    try {
      result = (MCAmericanBasketEngine< LowDiscrepancy > *)new_MCAmericanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDAmericanBasketEngine__SWIG_11(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCAmericanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCAmericanBasketEngine< LowDiscrepancy > *)new_MCAmericanBasketEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDAmericanBasketEngine(void * jarg1) {
  MCAmericanBasketEngine< LowDiscrepancy > *arg1 = (MCAmericanBasketEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCAmericanBasketEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCAmericanBasketEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  StulzEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (StulzEngine *)new StulzEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  StulzEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_StulzEngine(void * jarg1) {
  StulzEngine *arg1 = (StulzEngine *) 0 ;
  ext::shared_ptr< StulzEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  StulzEngine > *)jarg1;
  arg1 = (StulzEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KirkEngine(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< BlackProcess > *arg1 = 0 ;
  ext::shared_ptr< BlackProcess > *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< BlackProcess > tempnull1 ;
  ext::shared_ptr< BlackProcess > tempnull2 ;
  KirkEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BlackProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< BlackProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (KirkEngine *)new KirkEngine((ext::shared_ptr< BlackProcess > const &)*arg1,(ext::shared_ptr< BlackProcess > 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 ? new ext::shared_ptr<  KirkEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_KirkEngine(void * jarg1) {
  KirkEngine *arg1 = (KirkEngine *) 0 ;
  ext::shared_ptr< KirkEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  KirkEngine > *)jarg1;
  arg1 = (KirkEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fd2dBlackScholesVanillaEngine__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, void * jarg8, unsigned int jarg9, double jarg10) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  FdmSchemeDesc *arg8 = 0 ;
  bool arg9 ;
  Real arg10 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  Fd2dBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (FdmSchemeDesc *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg9 = jarg9 ? true : false; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (Fd2dBlackScholesVanillaEngine *)new Fd2dBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6,arg7,(FdmSchemeDesc 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 = result ? new ext::shared_ptr<  Fd2dBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fd2dBlackScholesVanillaEngine__SWIG_1(void * jarg1, void * jarg2, double jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, void * jarg8, unsigned int jarg9) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  FdmSchemeDesc *arg8 = 0 ;
  bool arg9 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  Fd2dBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (FdmSchemeDesc *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg9 = jarg9 ? true : false; 
  {
    try {
      result = (Fd2dBlackScholesVanillaEngine *)new Fd2dBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6,arg7,(FdmSchemeDesc 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 = result ? new ext::shared_ptr<  Fd2dBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fd2dBlackScholesVanillaEngine__SWIG_2(void * jarg1, void * jarg2, double jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, void * jarg8) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  FdmSchemeDesc *arg8 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  Fd2dBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (FdmSchemeDesc *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Fd2dBlackScholesVanillaEngine *)new Fd2dBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6,arg7,(FdmSchemeDesc 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 ? new ext::shared_ptr<  Fd2dBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fd2dBlackScholesVanillaEngine__SWIG_3(void * jarg1, void * jarg2, double jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  Fd2dBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (Fd2dBlackScholesVanillaEngine *)new Fd2dBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  Fd2dBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fd2dBlackScholesVanillaEngine__SWIG_4(void * jarg1, void * jarg2, double jarg3, unsigned long jarg4, unsigned long jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  Fd2dBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (Fd2dBlackScholesVanillaEngine *)new Fd2dBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  Fd2dBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fd2dBlackScholesVanillaEngine__SWIG_5(void * jarg1, void * jarg2, double jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  Fd2dBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (Fd2dBlackScholesVanillaEngine *)new Fd2dBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  Fd2dBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fd2dBlackScholesVanillaEngine__SWIG_6(void * jarg1, void * jarg2, double jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  Size arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  Fd2dBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (Fd2dBlackScholesVanillaEngine *)new Fd2dBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  Fd2dBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fd2dBlackScholesVanillaEngine__SWIG_7(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  Fd2dBlackScholesVanillaEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Fd2dBlackScholesVanillaEngine *)new Fd2dBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  Fd2dBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Fd2dBlackScholesVanillaEngine(void * jarg1) {
  Fd2dBlackScholesVanillaEngine *arg1 = (Fd2dBlackScholesVanillaEngine *) 0 ;
  ext::shared_ptr< Fd2dBlackScholesVanillaEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Fd2dBlackScholesVanillaEngine > *)jarg1;
  arg1 = (Fd2dBlackScholesVanillaEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< Exercise > *arg3 = 0 ;
  ext::shared_ptr< Exercise > tempnull3 ;
  EverestOption *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< Exercise > *)jarg3 : &tempnull3; 
  {
    try {
      result = (EverestOption *)new EverestOption(arg1,arg2,(ext::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 = result ? new ext::shared_ptr<  EverestOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EverestOption(void * jarg1) {
  EverestOption *arg1 = (EverestOption *) 0 ;
  ext::shared_ptr< EverestOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EverestOption > *)jarg1;
  arg1 = (EverestOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREverestEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  {
    try {
      result = (MCEverestEngine< PseudoRandom > *)new_MCEverestEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCEverestEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREverestEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCEverestEngine< PseudoRandom > *)new_MCEverestEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCEverestEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREverestEngine__SWIG_2(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCEverestEngine< PseudoRandom > *)new_MCEverestEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCEverestEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREverestEngine__SWIG_3(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCEverestEngine< PseudoRandom > *)new_MCEverestEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCEverestEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREverestEngine__SWIG_4(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCEverestEngine< PseudoRandom > *)new_MCEverestEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCEverestEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREverestEngine__SWIG_5(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCEverestEngine< PseudoRandom > *)new_MCEverestEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCEverestEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREverestEngine__SWIG_6(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (MCEverestEngine< PseudoRandom > *)new_MCEverestEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCEverestEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREverestEngine__SWIG_7(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (MCEverestEngine< PseudoRandom > *)new_MCEverestEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCEverestEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPREverestEngine__SWIG_8(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCEverestEngine< PseudoRandom > *)new_MCEverestEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCEverestEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPREverestEngine(void * jarg1) {
  MCEverestEngine< PseudoRandom > *arg1 = (MCEverestEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCEverestEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCEverestEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCEverestEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEverestEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8, long jarg9) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  BigInteger arg9 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  arg9 = (BigInteger)jarg9; 
  {
    try {
      result = (MCEverestEngine< LowDiscrepancy > *)new_MCEverestEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCEverestEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEverestEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7, int jarg8) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  intOrNull arg8 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  arg8 = (intOrNull)jarg8; 
  {
    try {
      result = (MCEverestEngine< LowDiscrepancy > *)new_MCEverestEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCEverestEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEverestEngine__SWIG_2(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (MCEverestEngine< LowDiscrepancy > *)new_MCEverestEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCEverestEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEverestEngine__SWIG_3(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  bool arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCEverestEngine< LowDiscrepancy > *)new_MCEverestEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCEverestEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEverestEngine__SWIG_4(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (MCEverestEngine< LowDiscrepancy > *)new_MCEverestEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCEverestEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEverestEngine__SWIG_5(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  bool arg4 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MCEverestEngine< LowDiscrepancy > *)new_MCEverestEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCEverestEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEverestEngine__SWIG_6(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (MCEverestEngine< LowDiscrepancy > *)new_MCEverestEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCEverestEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEverestEngine__SWIG_7(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (MCEverestEngine< LowDiscrepancy > *)new_MCEverestEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCEverestEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDEverestEngine__SWIG_8(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCEverestEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCEverestEngine< LowDiscrepancy > *)new_MCEverestEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCEverestEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDEverestEngine(void * jarg1) {
  MCEverestEngine< LowDiscrepancy > *arg1 = (MCEverestEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCEverestEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCEverestEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCEverestEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  HimalayaOption *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (HimalayaOption *)new HimalayaOption((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 = result ? new ext::shared_ptr<  HimalayaOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HimalayaOption(void * jarg1) {
  HimalayaOption *arg1 = (HimalayaOption *) 0 ;
  ext::shared_ptr< HimalayaOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  HimalayaOption > *)jarg1;
  arg1 = (HimalayaOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRHimalayaEngine__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5, int jarg6, long jarg7) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  intOrNull arg6 ;
  BigInteger arg7 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCHimalayaEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (BigInteger)jarg7; 
  {
    try {
      result = (MCHimalayaEngine< PseudoRandom > *)new_MCHimalayaEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*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 ? new ext::shared_ptr<  MCHimalayaEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRHimalayaEngine__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCHimalayaEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCHimalayaEngine< PseudoRandom > *)new_MCHimalayaEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 = result ? new ext::shared_ptr<  MCHimalayaEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRHimalayaEngine__SWIG_2(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCHimalayaEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  {
    try {
      result = (MCHimalayaEngine< PseudoRandom > *)new_MCHimalayaEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCHimalayaEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRHimalayaEngine__SWIG_3(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCHimalayaEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  {
    try {
      result = (MCHimalayaEngine< PseudoRandom > *)new_MCHimalayaEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCHimalayaEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRHimalayaEngine__SWIG_4(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCHimalayaEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (MCHimalayaEngine< PseudoRandom > *)new_MCHimalayaEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCHimalayaEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRHimalayaEngine__SWIG_5(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  bool arg2 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCHimalayaEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MCHimalayaEngine< PseudoRandom > *)new_MCHimalayaEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCHimalayaEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRHimalayaEngine__SWIG_6(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCHimalayaEngine< PseudoRandom > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCHimalayaEngine< PseudoRandom > *)new_MCHimalayaEngine_Sl_PseudoRandom_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCHimalayaEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPRHimalayaEngine(void * jarg1) {
  MCHimalayaEngine< PseudoRandom > *arg1 = (MCHimalayaEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCHimalayaEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCHimalayaEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCHimalayaEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDHimalayaEngine__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5, int jarg6, long jarg7) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  intOrNull arg6 ;
  BigInteger arg7 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCHimalayaEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (BigInteger)jarg7; 
  {
    try {
      result = (MCHimalayaEngine< LowDiscrepancy > *)new_MCHimalayaEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*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 ? new ext::shared_ptr<  MCHimalayaEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDHimalayaEngine__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  intOrNull arg6 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCHimalayaEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCHimalayaEngine< LowDiscrepancy > *)new_MCHimalayaEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 = result ? new ext::shared_ptr<  MCHimalayaEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDHimalayaEngine__SWIG_2(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCHimalayaEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  {
    try {
      result = (MCHimalayaEngine< LowDiscrepancy > *)new_MCHimalayaEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCHimalayaEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDHimalayaEngine__SWIG_3(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCHimalayaEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  {
    try {
      result = (MCHimalayaEngine< LowDiscrepancy > *)new_MCHimalayaEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCHimalayaEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDHimalayaEngine__SWIG_4(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCHimalayaEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (MCHimalayaEngine< LowDiscrepancy > *)new_MCHimalayaEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCHimalayaEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDHimalayaEngine__SWIG_5(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  bool arg2 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCHimalayaEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MCHimalayaEngine< LowDiscrepancy > *)new_MCHimalayaEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > 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 ? new ext::shared_ptr<  MCHimalayaEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDHimalayaEngine__SWIG_6(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempnull1 ;
  MCHimalayaEngine< LowDiscrepancy > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcessArray > *)jarg1 : &tempnull1; 
  {
    try {
      result = (MCHimalayaEngine< LowDiscrepancy > *)new_MCHimalayaEngine_Sl_LowDiscrepancy_Sg___SWIG_0((ext::shared_ptr< StochasticProcessArray > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCHimalayaEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDHimalayaEngine(void * jarg1) {
  MCHimalayaEngine< LowDiscrepancy > *arg1 = (MCHimalayaEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCHimalayaEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCHimalayaEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCHimalayaEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_blackFormulaImpliedStdDevLiRS__SWIG_0(int jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, double jarg9, unsigned int jarg10) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Natural arg10 ;
  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 = (Real)jarg9; 
  arg10 = (Natural)jarg10; 
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS(arg1,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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_blackFormulaImpliedStdDevLiRS__SWIG_1(int jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, double jarg9) {
  double jresult ;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  Real 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 = (Real)jarg9; 
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS(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_blackFormulaImpliedStdDevLiRS__SWIG_2(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)blackFormulaImpliedStdDevLiRS(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_blackFormulaImpliedStdDevLiRS__SWIG_3(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)blackFormulaImpliedStdDevLiRS(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_blackFormulaImpliedStdDevLiRS__SWIG_4(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)blackFormulaImpliedStdDevLiRS(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_blackFormulaImpliedStdDevLiRS__SWIG_5(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)blackFormulaImpliedStdDevLiRS(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_blackFormulaImpliedStdDevLiRS__SWIG_6(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)blackFormulaImpliedStdDevLiRS(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_blackFormulaImpliedStdDevLiRS__SWIG_7(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, unsigned int jarg9) {
  double jresult ;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  Natural arg9 ;
  ext::shared_ptr< PlainVanillaPayoff > tempnull1 ;
  Real result;
  
  arg1 = jarg1 ? (ext::shared_ptr< PlainVanillaPayoff > *)jarg1 : &tempnull1; 
  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)blackFormulaImpliedStdDevLiRS((ext::shared_ptr< PlainVanillaPayoff > const &)*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_blackFormulaImpliedStdDevLiRS__SWIG_8(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8) {
  double jresult ;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  ext::shared_ptr< PlainVanillaPayoff > tempnull1 ;
  Real result;
  
  arg1 = jarg1 ? (ext::shared_ptr< PlainVanillaPayoff > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS((ext::shared_ptr< PlainVanillaPayoff > const &)*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_blackFormulaImpliedStdDevLiRS__SWIG_9(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7) {
  double jresult ;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  ext::shared_ptr< PlainVanillaPayoff > tempnull1 ;
  Real result;
  
  arg1 = jarg1 ? (ext::shared_ptr< PlainVanillaPayoff > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS((ext::shared_ptr< PlainVanillaPayoff > const &)*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_blackFormulaImpliedStdDevLiRS__SWIG_10(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6) {
  double jresult ;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  ext::shared_ptr< PlainVanillaPayoff > tempnull1 ;
  Real result;
  
  arg1 = jarg1 ? (ext::shared_ptr< PlainVanillaPayoff > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS((ext::shared_ptr< PlainVanillaPayoff > 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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_blackFormulaImpliedStdDevLiRS__SWIG_11(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  ext::shared_ptr< PlainVanillaPayoff > tempnull1 ;
  Real result;
  
  arg1 = jarg1 ? (ext::shared_ptr< PlainVanillaPayoff > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS((ext::shared_ptr< PlainVanillaPayoff > 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 double SWIGSTDCALL CSharp_QuantLib_blackFormulaImpliedStdDevLiRS__SWIG_12(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  ext::shared_ptr< PlainVanillaPayoff > tempnull1 ;
  Real result;
  
  arg1 = jarg1 ? (ext::shared_ptr< PlainVanillaPayoff > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS((ext::shared_ptr< PlainVanillaPayoff > 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_blackFormulaImpliedStdDevLiRS__SWIG_13(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< PlainVanillaPayoff > tempnull1 ;
  Real result;
  
  arg1 = jarg1 ? (ext::shared_ptr< PlainVanillaPayoff > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS((ext::shared_ptr< PlainVanillaPayoff > 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 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_blackFormulaCashItmProbability__SWIG_2(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  ext::shared_ptr< PlainVanillaPayoff > tempnull1 ;
  Real result;
  
  arg1 = jarg1 ? (ext::shared_ptr< PlainVanillaPayoff > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)blackFormulaCashItmProbability((ext::shared_ptr< PlainVanillaPayoff > 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_blackFormulaCashItmProbability__SWIG_3(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< PlainVanillaPayoff > tempnull1 ;
  Real result;
  
  arg1 = jarg1 ? (ext::shared_ptr< PlainVanillaPayoff > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)blackFormulaCashItmProbability((ext::shared_ptr< PlainVanillaPayoff > 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 double SWIGSTDCALL CSharp_QuantLib_blackFormulaAssetItmProbability__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)blackFormulaAssetItmProbability(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_blackFormulaAssetItmProbability__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)blackFormulaAssetItmProbability(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_blackFormulaAssetItmProbability__SWIG_2(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  ext::shared_ptr< PlainVanillaPayoff > tempnull1 ;
  Real result;
  
  arg1 = jarg1 ? (ext::shared_ptr< PlainVanillaPayoff > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)blackFormulaAssetItmProbability((ext::shared_ptr< PlainVanillaPayoff > 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_blackFormulaAssetItmProbability__SWIG_3(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< PlainVanillaPayoff > tempnull1 ;
  Real result;
  
  arg1 = jarg1 ? (ext::shared_ptr< PlainVanillaPayoff > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)blackFormulaAssetItmProbability((ext::shared_ptr< PlainVanillaPayoff > 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 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 double SWIGSTDCALL CSharp_QuantLib_bachelierBlackFormulaAssetItmProbability__SWIG_0(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)bachelierBlackFormulaAssetItmProbability(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_bachelierBlackFormulaAssetItmProbability__SWIG_1(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< PlainVanillaPayoff > tempnull1 ;
  Real result;
  
  arg1 = jarg1 ? (ext::shared_ptr< PlainVanillaPayoff > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)bachelierBlackFormulaAssetItmProbability((ext::shared_ptr< PlainVanillaPayoff > 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_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_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 & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & 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 & 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(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__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > > *arg2 = 0 ;
  Swap *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CashFlow > > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CashFlow > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Swap *)new Swap((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(std::vector< ext::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 ? new ext::shared_ptr<  Swap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Swap__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< Leg > *arg1 = 0 ;
  std::vector< bool > *arg2 = 0 ;
  Swap *result = 0 ;
  
  arg1 = (std::vector< Leg > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Leg > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< bool > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Swap *)new Swap((std::vector< Leg > const &)*arg1,(std::vector< 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 ? new ext::shared_ptr<  Swap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_Swap_numberOfLegs(void * jarg1) {
  unsigned long jresult ;
  Swap *arg1 = (Swap *) 0 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const Swap > *)jarg1;
  arg1 = (Swap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Swap const *)arg1)->numberOfLegs();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_Swap_startDate(void * jarg1) {
  void * jresult ;
  Swap *arg1 = (Swap *) 0 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const Swap > *)jarg1;
  arg1 = (Swap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Swap const *)arg1)->startDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Swap_maturityDate(void * jarg1) {
  void * jresult ;
  Swap *arg1 = (Swap *) 0 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const Swap > *)jarg1;
  arg1 = (Swap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Swap const *)arg1)->maturityDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Swap_leg(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  Swap *arg1 = (Swap *) 0 ;
  Size arg2 ;
  ext::shared_ptr< Swap > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Swap > *)jarg1;
  arg1 = (Swap *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Leg *) &(arg1)->leg(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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 ;
  Swap *arg1 = (Swap *) 0 ;
  Size arg2 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Swap > *)jarg1;
  arg1 = (Swap *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Real)((Swap const *)arg1)->legNPV(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Swap_legBPS(void * jarg1, unsigned long jarg2) {
  double jresult ;
  Swap *arg1 = (Swap *) 0 ;
  Size arg2 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Swap > *)jarg1;
  arg1 = (Swap *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Real)((Swap const *)arg1)->legBPS(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Swap_startDiscounts(void * jarg1, unsigned long jarg2) {
  double jresult ;
  Swap *arg1 = (Swap *) 0 ;
  Size arg2 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  DiscountFactor result;
  
  
  smartarg1 = (ext::shared_ptr< const Swap > *)jarg1;
  arg1 = (Swap *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (DiscountFactor)((Swap const *)arg1)->startDiscounts(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Swap_endDiscounts(void * jarg1, unsigned long jarg2) {
  double jresult ;
  Swap *arg1 = (Swap *) 0 ;
  Size arg2 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  DiscountFactor result;
  
  
  smartarg1 = (ext::shared_ptr< const Swap > *)jarg1;
  arg1 = (Swap *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (DiscountFactor)((Swap const *)arg1)->endDiscounts(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Swap_npvDateDiscount(void * jarg1) {
  double jresult ;
  Swap *arg1 = (Swap *) 0 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  DiscountFactor result;
  
  
  smartarg1 = (ext::shared_ptr< const Swap > *)jarg1;
  arg1 = (Swap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (DiscountFactor)((Swap const *)arg1)->npvDateDiscount();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_Swap_payer(void * jarg1, unsigned long jarg2) {
  unsigned int jresult ;
  Swap *arg1 = (Swap *) 0 ;
  Size arg2 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const Swap > *)jarg1;
  arg1 = (Swap *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (bool)((Swap const *)arg1)->payer(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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) {
  Swap *arg1 = (Swap *) 0 ;
  ext::shared_ptr< Swap > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Swap > *)jarg1;
  arg1 = (Swap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_simplifyNotificationGraph__SWIG_0(void * jarg1, unsigned int jarg2) {
  Swap *arg1 = 0 ;
  bool arg2 ;
  
  
  arg1 = (Swap *)(((ext::shared_ptr<  Swap > *)jarg1) ? ((ext::shared_ptr<  Swap > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Swap & reference is null", 0);
    return ;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      simplifyNotificationGraph(*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_simplifyNotificationGraph__SWIG_1(void * jarg1) {
  Swap *arg1 = 0 ;
  
  
  arg1 = (Swap *)(((ext::shared_ptr<  Swap > *)jarg1) ? ((ext::shared_ptr<  Swap > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Swap & reference is null", 0);
    return ;
  } 
  {
    try {
      simplifyNotificationGraph(*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VanillaSwap__SWIG_0(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, double jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Spread arg8 ;
  DayCounter *arg9 = 0 ;
  SwigValueWrapper< ext::optional< bool > > arg10 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  ext::optional< bool > *argp10 ;
  VanillaSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Schedule *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Spread)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  argp10 = (ext::optional< bool > *)jarg10; 
  if (!argp10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg10 = *argp10; 
  {
    try {
      result = (VanillaSwap *)new_VanillaSwap__SWIG_0(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,arg8,(DayCounter const &)*arg9,SWIG_STD_MOVE(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 ? new ext::shared_ptr<  VanillaSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VanillaSwap__SWIG_1(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, double jarg8, void * jarg9) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Spread arg8 ;
  DayCounter *arg9 = 0 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  VanillaSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Schedule *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Spread)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (VanillaSwap *)new_VanillaSwap__SWIG_0(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  VanillaSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_VanillaSwap_type(void * jarg1) {
  int jresult ;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap const > *smartarg1 = 0 ;
  Swap::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Swap::Type)((VanillaSwap 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_VanillaSwap_fairRate(void * jarg1) {
  double jresult ;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)(arg1)->fairRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  Spread result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Spread)(arg1)->fairSpread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->fixedLegBPS();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->floatingLegBPS();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->fixedLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->floatingLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &(arg1)->fixedLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &(arg1)->floatingLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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 ;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->nominal();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  Schedule *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Schedule *) &(arg1)->fixedSchedule();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  Schedule *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Schedule *) &(arg1)->floatingSchedule();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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 ;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)(arg1)->fixedRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  Spread result;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Spread)(arg1)->spread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  DayCounter *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (DayCounter *) &(arg1)->floatingDayCount();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  DayCounter *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (DayCounter *) &(arg1)->fixedDayCount();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(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) {
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwap > *)jarg1;
  arg1 = (VanillaSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_receiveFixed__SWIG_0(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  bool arg2 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->receiveFixed(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withType(void * jarg1, int jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Swap::Type arg2 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (Swap::Type)jarg2; 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withType(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withNominal(void * jarg1, double jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Real arg2 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withNominal(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withSettlementDays(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Natural arg2 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (Natural)jarg2; 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withSettlementDays(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withEffectiveDate(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Date *arg2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withEffectiveDate((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_MakeVanillaSwap_withTerminationDate(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Date *arg2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withTerminationDate((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_MakeVanillaSwap_withRule(void * jarg1, int jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  DateGeneration::Rule arg2 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (DateGeneration::Rule)jarg2; 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withRule(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withFixedLegTenor(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Period *arg2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegTenor((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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withFixedLegCalendar(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Calendar *arg2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegCalendar((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_MakeVanillaSwap_withFixedLegConvention(void * jarg1, int jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  BusinessDayConvention arg2 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (BusinessDayConvention)jarg2; 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegConvention(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withFixedLegRule(void * jarg1, int jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  DateGeneration::Rule arg2 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (DateGeneration::Rule)jarg2; 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegRule(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withFixedLegEndOfMonth__SWIG_0(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  bool arg2 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegEndOfMonth(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withFixedLegFirstDate(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Date *arg2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegFirstDate((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_MakeVanillaSwap_withFixedLegNextToLastDate(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Date *arg2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegNextToLastDate((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_MakeVanillaSwap_withFixedLegDayCount(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  DayCounter *arg2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegDayCount((DayCounter const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withFloatingLegTenor(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Period *arg2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegTenor((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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withFloatingLegCalendar(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Calendar *arg2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegCalendar((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_MakeVanillaSwap_withFloatingLegConvention(void * jarg1, int jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  BusinessDayConvention arg2 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (BusinessDayConvention)jarg2; 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegConvention(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withFloatingLegRule(void * jarg1, int jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  DateGeneration::Rule arg2 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (DateGeneration::Rule)jarg2; 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegRule(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withFloatingLegEndOfMonth__SWIG_0(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  bool arg2 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegEndOfMonth(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withFloatingLegFirstDate(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Date *arg2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegFirstDate((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_MakeVanillaSwap_withFloatingLegNextToLastDate(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Date *arg2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegNextToLastDate((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_MakeVanillaSwap_withFloatingLegDayCount(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  DayCounter *arg2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegDayCount((DayCounter const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withFloatingLegSpread(void * jarg1, double jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Spread arg2 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (Spread)jarg2; 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegSpread(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withDiscountingTermStructure(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withDiscountingTermStructure((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_MakeVanillaSwap_withPricingEngine(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  ext::shared_ptr< PricingEngine > *arg2 = 0 ;
  ext::shared_ptr< PricingEngine > tempnull2 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< PricingEngine > *)jarg2 : &tempnull2; 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withPricingEngine((ext::shared_ptr< PricingEngine > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withIndexedCoupons__SWIG_0(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  bool arg2 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withIndexedCoupons(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeVanillaSwap_withAtParCoupons__SWIG_0(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  bool arg2 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withAtParCoupons(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MakeVanillaSwap(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  Period *arg1 = 0 ;
  ext::shared_ptr< IborIndex > *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  ext::shared_ptr< IborIndex > tempnull2 ;
  MakeVanillaSwap *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< IborIndex > *)jarg2 : &tempnull2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeVanillaSwap *)new MakeVanillaSwap((Period const &)*arg1,(ext::shared_ptr< IborIndex > const &)*arg2,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_MakeVanillaSwap_makeVanillaSwap(void * jarg1) {
  void * jresult ;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  ext::shared_ptr< VanillaSwap > result;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  {
    try {
      result = MakeVanillaSwap_makeVanillaSwap(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< VanillaSwap >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MakeVanillaSwap(void * jarg1) {
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  
  arg1 = (MakeVanillaSwap *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Swap::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 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  bool arg13 ;
  BusinessDayConvention arg14 ;
  ext::shared_ptr< IborIndex > tempnull8 ;
  NonstandardSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< IborIndex > *)jarg8 : &tempnull8; 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  arg14 = (BusinessDayConvention)jarg14; 
  {
    try {
      result = (NonstandardSwap *)new NonstandardSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(std::vector< Real > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< IborIndex > const &)*arg8,(std::vector< Real > const &)*arg9,(std::vector< Spread > 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 = result ? new ext::shared_ptr<  NonstandardSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Swap::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 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  bool arg13 ;
  ext::shared_ptr< IborIndex > tempnull8 ;
  NonstandardSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< IborIndex > *)jarg8 : &tempnull8; 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (NonstandardSwap *)new NonstandardSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(std::vector< Real > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< IborIndex > const &)*arg8,(std::vector< Real > const &)*arg9,(std::vector< Spread > 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 = result ? new ext::shared_ptr<  NonstandardSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Swap::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 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  ext::shared_ptr< IborIndex > tempnull8 ;
  NonstandardSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< IborIndex > *)jarg8 : &tempnull8; 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (NonstandardSwap *)new NonstandardSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(std::vector< Real > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< IborIndex > const &)*arg8,(std::vector< Real > const &)*arg9,(std::vector< Spread > 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 = result ? new ext::shared_ptr<  NonstandardSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Swap::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 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  ext::shared_ptr< IborIndex > tempnull8 ;
  NonstandardSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< IborIndex > *)jarg8 : &tempnull8; 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (NonstandardSwap *)new NonstandardSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(std::vector< Real > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< IborIndex > const &)*arg8,(std::vector< Real > const &)*arg9,(std::vector< Spread > 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 = result ? new ext::shared_ptr<  NonstandardSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_type(void * jarg1) {
  int jresult ;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  Swap::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Swap::Type)((NonstandardSwap 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_NonstandardSwap_fixedNominal(void * jarg1) {
  void * jresult ;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((NonstandardSwap const *)arg1)->fixedNominal();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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_floatingNominal(void * jarg1) {
  void * jresult ;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((NonstandardSwap const *)arg1)->floatingNominal();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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_fixedSchedule(void * jarg1) {
  void * jresult ;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  Schedule *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Schedule *) &((NonstandardSwap const *)arg1)->fixedSchedule();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((NonstandardSwap const *)arg1)->fixedRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  DayCounter *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (DayCounter *) &((NonstandardSwap const *)arg1)->fixedDayCount();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  Schedule *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Schedule *) &((NonstandardSwap const *)arg1)->floatingSchedule();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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_iborIndex(void * jarg1) {
  void * jresult ;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  ext::shared_ptr< IborIndex > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (ext::shared_ptr< IborIndex > *) &((NonstandardSwap const *)arg1)->iborIndex();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = *result ? new ext::shared_ptr< IborIndex >(*result) : 0; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_spread(void * jarg1) {
  double jresult ;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  Spread result;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Spread)((NonstandardSwap const *)arg1)->spread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_gearing(void * jarg1) {
  double jresult ;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((NonstandardSwap const *)arg1)->gearing();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_spreads(void * jarg1) {
  void * jresult ;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  std::vector< Spread > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Spread > *) &((NonstandardSwap const *)arg1)->spreads();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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_gearings(void * jarg1) {
  void * jresult ;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((NonstandardSwap const *)arg1)->gearings();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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_floatingDayCount(void * jarg1) {
  void * jresult ;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  DayCounter *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (DayCounter *) &((NonstandardSwap const *)arg1)->floatingDayCount();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_NonstandardSwap_paymentConvention(void * jarg1) {
  int jresult ;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  BusinessDayConvention result;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (BusinessDayConvention)((NonstandardSwap const *)arg1)->paymentConvention();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_NonstandardSwap_fixedLeg(void * jarg1) {
  void * jresult ;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &((NonstandardSwap const *)arg1)->fixedLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &((NonstandardSwap const *)arg1)->floatingLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(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) {
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  ext::shared_ptr< NonstandardSwap > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  NonstandardSwap > *)jarg1;
  arg1 = (NonstandardSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, unsigned int jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  bool arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  DiscountingSwapEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountingSwapEngine *)new DiscountingSwapEngine((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 = result ? new ext::shared_ptr<  DiscountingSwapEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscountingSwapEngine__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  bool arg2 ;
  Date *arg3 = 0 ;
  DiscountingSwapEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountingSwapEngine *)new DiscountingSwapEngine((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 = result ? new ext::shared_ptr<  DiscountingSwapEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscountingSwapEngine__SWIG_2(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  bool arg2 ;
  DiscountingSwapEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (DiscountingSwapEngine *)new DiscountingSwapEngine((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 = result ? new ext::shared_ptr<  DiscountingSwapEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscountingSwapEngine__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DiscountingSwapEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountingSwapEngine *)new_DiscountingSwapEngine__SWIG_3((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 = result ? new ext::shared_ptr<  DiscountingSwapEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscountingSwapEngine__SWIG_4(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Date *arg2 = 0 ;
  DiscountingSwapEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountingSwapEngine *)new_DiscountingSwapEngine__SWIG_3((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 = result ? new ext::shared_ptr<  DiscountingSwapEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DiscountingSwapEngine__SWIG_5(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  DiscountingSwapEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountingSwapEngine *)new_DiscountingSwapEngine__SWIG_3((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 = result ? new ext::shared_ptr<  DiscountingSwapEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DiscountingSwapEngine(void * jarg1) {
  DiscountingSwapEngine *arg1 = (DiscountingSwapEngine *) 0 ;
  ext::shared_ptr< DiscountingSwapEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DiscountingSwapEngine > *)jarg1;
  arg1 = (DiscountingSwapEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< Bond > *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Spread arg5 ;
  Schedule *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AssetSwap *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (ext::shared_ptr< Bond > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ext::shared_ptr< Bond > const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Spread)jarg5; 
  arg6 = (Schedule *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (AssetSwap *)new AssetSwap(arg1,(ext::shared_ptr< Bond > const &)*arg2,arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  AssetSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< Bond > *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Spread arg5 ;
  Schedule *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AssetSwap *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (ext::shared_ptr< Bond > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ext::shared_ptr< Bond > const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Spread)jarg5; 
  arg6 = (Schedule *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AssetSwap *)new AssetSwap(arg1,(ext::shared_ptr< Bond > const &)*arg2,arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  AssetSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< Bond > *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Spread arg5 ;
  Schedule *arg6 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AssetSwap *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (ext::shared_ptr< Bond > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ext::shared_ptr< Bond > const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Spread)jarg5; 
  arg6 = (Schedule *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AssetSwap *)new AssetSwap(arg1,(ext::shared_ptr< Bond > const &)*arg2,arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  AssetSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< Bond > *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Spread arg5 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AssetSwap *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (ext::shared_ptr< Bond > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ext::shared_ptr< Bond > const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Spread)jarg5; 
  {
    try {
      result = (AssetSwap *)new AssetSwap(arg1,(ext::shared_ptr< Bond > const &)*arg2,arg3,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  AssetSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_AssetSwap_fairCleanPrice(void * jarg1) {
  double jresult ;
  AssetSwap *arg1 = (AssetSwap *) 0 ;
  ext::shared_ptr< AssetSwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  AssetSwap > *)jarg1;
  arg1 = (AssetSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->fairCleanPrice();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  AssetSwap *arg1 = (AssetSwap *) 0 ;
  ext::shared_ptr< AssetSwap > *smartarg1 = 0 ;
  Spread result;
  
  
  smartarg1 = (ext::shared_ptr<  AssetSwap > *)jarg1;
  arg1 = (AssetSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Spread)(arg1)->fairSpread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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) {
  AssetSwap *arg1 = (AssetSwap *) 0 ;
  ext::shared_ptr< AssetSwap > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AssetSwap > *)jarg1;
  arg1 = (AssetSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *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 ;
  ext::shared_ptr< InterestRateIndex > tempnull5 ;
  ext::shared_ptr< InterestRateIndex > tempnull8 ;
  FloatFloatSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< InterestRateIndex > *)jarg5 : &tempnull5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< InterestRateIndex > *)jarg8 : &tempnull8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg14 = (std::vector< Real > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg15 = (std::vector< Real > *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg16 = (std::vector< Real > *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg17 = (std::vector< Real > *)jarg17;
  if (!arg17) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg18 = (std::vector< Real > *)jarg18;
  if (!arg18) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg19 = (std::vector< Real > *)jarg19;
  if (!arg19) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg20 = (BusinessDayConvention)jarg20; 
  arg21 = (BusinessDayConvention)jarg21; 
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real > const &)*arg12,(std::vector< Real > const &)*arg13,(std::vector< Real > const &)*arg14,(std::vector< Real > const &)*arg15,(std::vector< Real > const &)*arg16,(std::vector< Real > const &)*arg17,(std::vector< Real > const &)*arg18,(std::vector< Real > 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 = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *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 ;
  ext::shared_ptr< InterestRateIndex > tempnull5 ;
  ext::shared_ptr< InterestRateIndex > tempnull8 ;
  FloatFloatSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< InterestRateIndex > *)jarg5 : &tempnull5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< InterestRateIndex > *)jarg8 : &tempnull8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg14 = (std::vector< Real > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg15 = (std::vector< Real > *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg16 = (std::vector< Real > *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg17 = (std::vector< Real > *)jarg17;
  if (!arg17) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg18 = (std::vector< Real > *)jarg18;
  if (!arg18) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg19 = (std::vector< Real > *)jarg19;
  if (!arg19) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg20 = (BusinessDayConvention)jarg20; 
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real > const &)*arg12,(std::vector< Real > const &)*arg13,(std::vector< Real > const &)*arg14,(std::vector< Real > const &)*arg15,(std::vector< Real > const &)*arg16,(std::vector< Real > const &)*arg17,(std::vector< Real > const &)*arg18,(std::vector< Real > 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 = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *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 ;
  ext::shared_ptr< InterestRateIndex > tempnull5 ;
  ext::shared_ptr< InterestRateIndex > tempnull8 ;
  FloatFloatSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< InterestRateIndex > *)jarg5 : &tempnull5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< InterestRateIndex > *)jarg8 : &tempnull8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg14 = (std::vector< Real > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg15 = (std::vector< Real > *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg16 = (std::vector< Real > *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg17 = (std::vector< Real > *)jarg17;
  if (!arg17) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg18 = (std::vector< Real > *)jarg18;
  if (!arg18) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg19 = (std::vector< Real > *)jarg19;
  if (!arg19) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real > const &)*arg12,(std::vector< Real > const &)*arg13,(std::vector< Real > const &)*arg14,(std::vector< Real > const &)*arg15,(std::vector< Real > const &)*arg16,(std::vector< Real > const &)*arg17,(std::vector< Real > const &)*arg18,(std::vector< Real > 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 = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *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 ;
  ext::shared_ptr< InterestRateIndex > tempnull5 ;
  ext::shared_ptr< InterestRateIndex > tempnull8 ;
  FloatFloatSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< InterestRateIndex > *)jarg5 : &tempnull5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< InterestRateIndex > *)jarg8 : &tempnull8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg14 = (std::vector< Real > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg15 = (std::vector< Real > *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg16 = (std::vector< Real > *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg17 = (std::vector< Real > *)jarg17;
  if (!arg17) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg18 = (std::vector< Real > *)jarg18;
  if (!arg18) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real > const &)*arg12,(std::vector< Real > const &)*arg13,(std::vector< Real > const &)*arg14,(std::vector< Real > const &)*arg15,(std::vector< Real > const &)*arg16,(std::vector< Real > const &)*arg17,(std::vector< Real > 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 = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *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 ;
  ext::shared_ptr< InterestRateIndex > tempnull5 ;
  ext::shared_ptr< InterestRateIndex > tempnull8 ;
  FloatFloatSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< InterestRateIndex > *)jarg5 : &tempnull5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< InterestRateIndex > *)jarg8 : &tempnull8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg14 = (std::vector< Real > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg15 = (std::vector< Real > *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg16 = (std::vector< Real > *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg17 = (std::vector< Real > *)jarg17;
  if (!arg17) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real > const &)*arg12,(std::vector< Real > const &)*arg13,(std::vector< Real > const &)*arg14,(std::vector< Real > const &)*arg15,(std::vector< Real > const &)*arg16,(std::vector< Real > 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 = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *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 ;
  ext::shared_ptr< InterestRateIndex > tempnull5 ;
  ext::shared_ptr< InterestRateIndex > tempnull8 ;
  FloatFloatSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< InterestRateIndex > *)jarg5 : &tempnull5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< InterestRateIndex > *)jarg8 : &tempnull8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg14 = (std::vector< Real > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg15 = (std::vector< Real > *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg16 = (std::vector< Real > *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real > const &)*arg12,(std::vector< Real > const &)*arg13,(std::vector< Real > const &)*arg14,(std::vector< Real > const &)*arg15,(std::vector< Real > 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 = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *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 ;
  ext::shared_ptr< InterestRateIndex > tempnull5 ;
  ext::shared_ptr< InterestRateIndex > tempnull8 ;
  FloatFloatSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< InterestRateIndex > *)jarg5 : &tempnull5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< InterestRateIndex > *)jarg8 : &tempnull8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg14 = (std::vector< Real > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg15 = (std::vector< Real > *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real > const &)*arg12,(std::vector< Real > const &)*arg13,(std::vector< Real > const &)*arg14,(std::vector< Real > 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 = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real > *arg12 = 0 ;
  std::vector< Real > *arg13 = 0 ;
  std::vector< Real > *arg14 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempnull5 ;
  ext::shared_ptr< InterestRateIndex > tempnull8 ;
  FloatFloatSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< InterestRateIndex > *)jarg5 : &tempnull5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< InterestRateIndex > *)jarg8 : &tempnull8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg14 = (std::vector< Real > *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real > const &)*arg12,(std::vector< Real > const &)*arg13,(std::vector< Real > 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 = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real > *arg12 = 0 ;
  std::vector< Real > *arg13 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempnull5 ;
  ext::shared_ptr< InterestRateIndex > tempnull8 ;
  FloatFloatSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< InterestRateIndex > *)jarg5 : &tempnull5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< InterestRateIndex > *)jarg8 : &tempnull8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg13 = (std::vector< Real > *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real > const &)*arg12,(std::vector< Real > 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 = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real > *arg12 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempnull5 ;
  ext::shared_ptr< InterestRateIndex > tempnull8 ;
  FloatFloatSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< InterestRateIndex > *)jarg5 : &tempnull5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< InterestRateIndex > *)jarg8 : &tempnull8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real > 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 = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  ext::shared_ptr< InterestRateIndex > tempnull5 ;
  ext::shared_ptr< InterestRateIndex > tempnull8 ;
  FloatFloatSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< InterestRateIndex > *)jarg5 : &tempnull5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< InterestRateIndex > *)jarg8 : &tempnull8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > 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 = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  ext::shared_ptr< InterestRateIndex > tempnull5 ;
  ext::shared_ptr< InterestRateIndex > tempnull8 ;
  FloatFloatSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< InterestRateIndex > *)jarg5 : &tempnull5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< InterestRateIndex > *)jarg8 : &tempnull8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? true : false; 
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > 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 = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempnull5 ;
  ext::shared_ptr< InterestRateIndex > tempnull8 ;
  FloatFloatSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< InterestRateIndex > *)jarg5 : &tempnull5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< InterestRateIndex > *)jarg8 : &tempnull8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real > const &)*arg2,(std::vector< Real > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > 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 = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FloatFloatSwap(void * jarg1) {
  FloatFloatSwap *arg1 = (FloatFloatSwap *) 0 ;
  ext::shared_ptr< FloatFloatSwap > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FloatFloatSwap > *)jarg1;
  arg1 = (FloatFloatSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_0(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, double jarg7, int jarg8, int jarg9, void * jarg10, unsigned int jarg11, int jarg12) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  SwigValueWrapper< Calendar > arg10 ;
  bool arg11 ;
  RateAveraging::Type arg12 ;
  ext::shared_ptr< OvernightIndex > tempnull6 ;
  Calendar *argp10 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< OvernightIndex > *)jarg6 : &tempnull6; 
  arg7 = (Spread)jarg7; 
  arg8 = (Integer)jarg8; 
  arg9 = (BusinessDayConvention)jarg9; 
  argp10 = (Calendar *)jarg10; 
  if (!argp10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg10 = *argp10; 
  arg11 = jarg11 ? true : false; 
  arg12 = (RateAveraging::Type)jarg12; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*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 ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_1(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, double jarg7, int jarg8, int jarg9, void * jarg10, unsigned int jarg11) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  SwigValueWrapper< Calendar > arg10 ;
  bool arg11 ;
  ext::shared_ptr< OvernightIndex > tempnull6 ;
  Calendar *argp10 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< OvernightIndex > *)jarg6 : &tempnull6; 
  arg7 = (Spread)jarg7; 
  arg8 = (Integer)jarg8; 
  arg9 = (BusinessDayConvention)jarg9; 
  argp10 = (Calendar *)jarg10; 
  if (!argp10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg10 = *argp10; 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*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 ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_2(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, double jarg7, int jarg8, int jarg9, void * jarg10) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  SwigValueWrapper< Calendar > arg10 ;
  ext::shared_ptr< OvernightIndex > tempnull6 ;
  Calendar *argp10 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< OvernightIndex > *)jarg6 : &tempnull6; 
  arg7 = (Spread)jarg7; 
  arg8 = (Integer)jarg8; 
  arg9 = (BusinessDayConvention)jarg9; 
  argp10 = (Calendar *)jarg10; 
  if (!argp10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg10 = *argp10; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_3(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, double jarg7, int jarg8, int jarg9) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  ext::shared_ptr< OvernightIndex > tempnull6 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< OvernightIndex > *)jarg6 : &tempnull6; 
  arg7 = (Spread)jarg7; 
  arg8 = (Integer)jarg8; 
  arg9 = (BusinessDayConvention)jarg9; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_4(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, double jarg7, int jarg8) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  ext::shared_ptr< OvernightIndex > tempnull6 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< OvernightIndex > *)jarg6 : &tempnull6; 
  arg7 = (Spread)jarg7; 
  arg8 = (Integer)jarg8; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > 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 ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_5(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, double jarg7) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  ext::shared_ptr< OvernightIndex > tempnull6 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< OvernightIndex > *)jarg6 : &tempnull6; 
  arg7 = (Spread)jarg7; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > 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 ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_6(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull6 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< OvernightIndex > *)jarg6 : &tempnull6; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > 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 ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_7(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, double jarg7, int jarg8, int jarg9, void * jarg10, unsigned int jarg11, int jarg12) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  SwigValueWrapper< Calendar > arg10 ;
  bool arg11 ;
  RateAveraging::Type arg12 ;
  std::vector< Real > *argp2 ;
  ext::shared_ptr< OvernightIndex > tempnull6 ;
  Calendar *argp10 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  argp2 = (std::vector< Real > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< OvernightIndex > *)jarg6 : &tempnull6; 
  arg7 = (Spread)jarg7; 
  arg8 = (Integer)jarg8; 
  arg9 = (BusinessDayConvention)jarg9; 
  argp10 = (Calendar *)jarg10; 
  if (!argp10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg10 = *argp10; 
  arg11 = jarg11 ? true : false; 
  arg12 = (RateAveraging::Type)jarg12; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*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 ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_8(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, double jarg7, int jarg8, int jarg9, void * jarg10, unsigned int jarg11) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  SwigValueWrapper< Calendar > arg10 ;
  bool arg11 ;
  std::vector< Real > *argp2 ;
  ext::shared_ptr< OvernightIndex > tempnull6 ;
  Calendar *argp10 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  argp2 = (std::vector< Real > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< OvernightIndex > *)jarg6 : &tempnull6; 
  arg7 = (Spread)jarg7; 
  arg8 = (Integer)jarg8; 
  arg9 = (BusinessDayConvention)jarg9; 
  argp10 = (Calendar *)jarg10; 
  if (!argp10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg10 = *argp10; 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*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 ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_9(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, double jarg7, int jarg8, int jarg9, void * jarg10) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  SwigValueWrapper< Calendar > arg10 ;
  std::vector< Real > *argp2 ;
  ext::shared_ptr< OvernightIndex > tempnull6 ;
  Calendar *argp10 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  argp2 = (std::vector< Real > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< OvernightIndex > *)jarg6 : &tempnull6; 
  arg7 = (Spread)jarg7; 
  arg8 = (Integer)jarg8; 
  arg9 = (BusinessDayConvention)jarg9; 
  argp10 = (Calendar *)jarg10; 
  if (!argp10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg10 = *argp10; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_10(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, double jarg7, int jarg8, int jarg9) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  std::vector< Real > *argp2 ;
  ext::shared_ptr< OvernightIndex > tempnull6 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  argp2 = (std::vector< Real > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< OvernightIndex > *)jarg6 : &tempnull6; 
  arg7 = (Spread)jarg7; 
  arg8 = (Integer)jarg8; 
  arg9 = (BusinessDayConvention)jarg9; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_11(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, double jarg7, int jarg8) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  std::vector< Real > *argp2 ;
  ext::shared_ptr< OvernightIndex > tempnull6 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  argp2 = (std::vector< Real > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< OvernightIndex > *)jarg6 : &tempnull6; 
  arg7 = (Spread)jarg7; 
  arg8 = (Integer)jarg8; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > 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 ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_12(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, double jarg7) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  std::vector< Real > *argp2 ;
  ext::shared_ptr< OvernightIndex > tempnull6 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  argp2 = (std::vector< Real > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< OvernightIndex > *)jarg6 : &tempnull6; 
  arg7 = (Spread)jarg7; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > 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 ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_13(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  std::vector< Real > *argp2 ;
  ext::shared_ptr< OvernightIndex > tempnull6 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  argp2 = (std::vector< Real > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< OvernightIndex > *)jarg6 : &tempnull6; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > 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 ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_14(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, int jarg10, int jarg11, void * jarg12, unsigned int jarg13, int jarg14) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg8 = 0 ;
  Spread arg9 ;
  Integer arg10 ;
  BusinessDayConvention arg11 ;
  Calendar *arg12 = 0 ;
  bool arg13 ;
  RateAveraging::Type arg14 ;
  ext::shared_ptr< OvernightIndex > tempnull8 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< OvernightIndex > *)jarg8 : &tempnull8; 
  arg9 = (Spread)jarg9; 
  arg10 = (Integer)jarg10; 
  arg11 = (BusinessDayConvention)jarg11; 
  arg12 = (Calendar *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg13 = jarg13 ? true : false; 
  arg14 = (RateAveraging::Type)jarg14; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(std::vector< Real > const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< OvernightIndex > const &)*arg8,arg9,arg10,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 = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_15(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, int jarg10, int jarg11, void * jarg12, unsigned int jarg13) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg8 = 0 ;
  Spread arg9 ;
  Integer arg10 ;
  BusinessDayConvention arg11 ;
  Calendar *arg12 = 0 ;
  bool arg13 ;
  ext::shared_ptr< OvernightIndex > tempnull8 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< OvernightIndex > *)jarg8 : &tempnull8; 
  arg9 = (Spread)jarg9; 
  arg10 = (Integer)jarg10; 
  arg11 = (BusinessDayConvention)jarg11; 
  arg12 = (Calendar *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(std::vector< Real > const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< OvernightIndex > const &)*arg8,arg9,arg10,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 = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_16(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, int jarg10, int jarg11, void * jarg12) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg8 = 0 ;
  Spread arg9 ;
  Integer arg10 ;
  BusinessDayConvention arg11 ;
  Calendar *arg12 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull8 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< OvernightIndex > *)jarg8 : &tempnull8; 
  arg9 = (Spread)jarg9; 
  arg10 = (Integer)jarg10; 
  arg11 = (BusinessDayConvention)jarg11; 
  arg12 = (Calendar *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(std::vector< Real > const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< OvernightIndex > const &)*arg8,arg9,arg10,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 = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_17(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, int jarg10, int jarg11) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg8 = 0 ;
  Spread arg9 ;
  Integer arg10 ;
  BusinessDayConvention arg11 ;
  ext::shared_ptr< OvernightIndex > tempnull8 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< OvernightIndex > *)jarg8 : &tempnull8; 
  arg9 = (Spread)jarg9; 
  arg10 = (Integer)jarg10; 
  arg11 = (BusinessDayConvention)jarg11; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(std::vector< Real > const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_18(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, int jarg10) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg8 = 0 ;
  Spread arg9 ;
  Integer arg10 ;
  ext::shared_ptr< OvernightIndex > tempnull8 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< OvernightIndex > *)jarg8 : &tempnull8; 
  arg9 = (Spread)jarg9; 
  arg10 = (Integer)jarg10; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(std::vector< Real > const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_19(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg8 = 0 ;
  Spread arg9 ;
  ext::shared_ptr< OvernightIndex > tempnull8 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< OvernightIndex > *)jarg8 : &tempnull8; 
  arg9 = (Spread)jarg9; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(std::vector< Real > const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwap__SWIG_20(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg8 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull8 ;
  OvernightIndexedSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< OvernightIndex > *)jarg8 : &tempnull8; 
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(std::vector< Real > const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< OvernightIndex > 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 ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwap_fixedLegBPS(void * jarg1) {
  double jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)(arg1)->fixedLegBPS();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwap_fixedLegNPV(void * jarg1) {
  double jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->fixedLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwap_fairRate(void * jarg1) {
  double jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->fairRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwap_overnightLegBPS(void * jarg1) {
  double jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->overnightLegBPS();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwap_overnightLegNPV(void * jarg1) {
  double jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->overnightLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwap_fairSpread(void * jarg1) {
  double jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  Spread result;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Spread)(arg1)->fairSpread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_OvernightIndexedSwap_type(void * jarg1) {
  int jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  Swap::Type result;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Swap::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 double SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwap_nominal(void * jarg1) {
  double jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->nominal();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwap_nominals(void * jarg1) {
  void * jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  std::vector< Real > result;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->nominals();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwap_paymentFrequency(void * jarg1) {
  int jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  Frequency result;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Frequency)(arg1)->paymentFrequency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_OvernightIndexedSwap_fixedRate(void * jarg1) {
  double jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)(arg1)->fixedRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwap_fixedDayCount(void * jarg1) {
  void * jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  DayCounter *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (DayCounter *) &(arg1)->fixedDayCount();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwap_overnightIndex(void * jarg1) {
  void * jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap const > *smartarg1 = 0 ;
  ext::shared_ptr< OvernightIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((OvernightIndexedSwap const *)arg1)->overnightIndex();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< OvernightIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwap_spread(void * jarg1) {
  double jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  Spread result;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Spread)(arg1)->spread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwap_fixedLeg(void * jarg1) {
  void * jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &(arg1)->fixedLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwap_overnightLeg(void * jarg1) {
  void * jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &(arg1)->overnightLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_OvernightIndexedSwap_averagingMethod(void * jarg1) {
  int jresult ;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  RateAveraging::Type result;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (RateAveraging::Type)(arg1)->averagingMethod();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_OvernightIndexedSwap(void * jarg1) {
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwap > *)jarg1;
  arg1 = (OvernightIndexedSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MakeOIS__SWIG_0(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  Period *arg1 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull2 ;
  MakeOIS *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< OvernightIndex > *)jarg2 : &tempnull2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeOIS *)new MakeOIS((Period const &)*arg1,(ext::shared_ptr< OvernightIndex > const &)*arg2,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_MakeOIS__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  Period *arg1 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg2 = 0 ;
  Rate arg3 ;
  ext::shared_ptr< OvernightIndex > tempnull2 ;
  MakeOIS *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< OvernightIndex > *)jarg2 : &tempnull2; 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (MakeOIS *)new MakeOIS((Period const &)*arg1,(ext::shared_ptr< OvernightIndex > 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_MakeOIS__SWIG_2(void * jarg1, void * jarg2) {
  void * jresult ;
  Period *arg1 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg2 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull2 ;
  MakeOIS *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< OvernightIndex > *)jarg2 : &tempnull2; 
  {
    try {
      result = (MakeOIS *)new MakeOIS((Period const &)*arg1,(ext::shared_ptr< OvernightIndex > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeOIS_makeOIS(void * jarg1) {
  void * jresult ;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  ext::shared_ptr< OvernightIndexedSwap > result;
  
  arg1 = (MakeOIS *)jarg1; 
  {
    try {
      result = MakeOIS_makeOIS(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< OvernightIndexedSwap >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeOIS_receiveFixed__SWIG_0(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  bool arg2 ;
  MakeOIS *result = 0 ;
  
  arg1 = (MakeOIS *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MakeOIS *) &(arg1)->receiveFixed(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeOIS_withType(void * jarg1, int jarg2) {
  void * jresult ;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Swap::Type arg2 ;
  MakeOIS *result = 0 ;
  
  arg1 = (MakeOIS *)jarg1; 
  arg2 = (Swap::Type)jarg2; 
  {
    try {
      result = (MakeOIS *) &(arg1)->withType(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeOIS_withNominal(void * jarg1, double jarg2) {
  void * jresult ;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Real arg2 ;
  MakeOIS *result = 0 ;
  
  arg1 = (MakeOIS *)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (MakeOIS *) &(arg1)->withNominal(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeOIS_withSettlementDays(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Natural arg2 ;
  MakeOIS *result = 0 ;
  
  arg1 = (MakeOIS *)jarg1; 
  arg2 = (Natural)jarg2; 
  {
    try {
      result = (MakeOIS *) &(arg1)->withSettlementDays(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeOIS_withEffectiveDate(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Date *arg2 = 0 ;
  MakeOIS *result = 0 ;
  
  arg1 = (MakeOIS *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeOIS *) &(arg1)->withEffectiveDate((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_MakeOIS_withTerminationDate(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Date *arg2 = 0 ;
  MakeOIS *result = 0 ;
  
  arg1 = (MakeOIS *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeOIS *) &(arg1)->withTerminationDate((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_MakeOIS_withRule(void * jarg1, int jarg2) {
  void * jresult ;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  DateGeneration::Rule arg2 ;
  MakeOIS *result = 0 ;
  
  arg1 = (MakeOIS *)jarg1; 
  arg2 = (DateGeneration::Rule)jarg2; 
  {
    try {
      result = (MakeOIS *) &(arg1)->withRule(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


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


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeOIS_withPaymentCalendar(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Calendar *arg2 = 0 ;
  MakeOIS *result = 0 ;
  
  arg1 = (MakeOIS *)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeOIS *) &(arg1)->withPaymentCalendar((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_MakeOIS_withEndOfMonth__SWIG_0(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  bool arg2 ;
  MakeOIS *result = 0 ;
  
  arg1 = (MakeOIS *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MakeOIS *) &(arg1)->withEndOfMonth(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeOIS_withOvernightLegSpread(void * jarg1, double jarg2) {
  void * jresult ;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Spread arg2 ;
  MakeOIS *result = 0 ;
  
  arg1 = (MakeOIS *)jarg1; 
  arg2 = (Spread)jarg2; 
  {
    try {
      result = (MakeOIS *) &(arg1)->withOvernightLegSpread(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeOIS_withDiscountingTermStructure(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  MakeOIS *result = 0 ;
  
  arg1 = (MakeOIS *)jarg1; 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MakeOIS *) &(arg1)->withDiscountingTermStructure((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_MakeOIS_withTelescopicValueDates(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  bool arg2 ;
  MakeOIS *result = 0 ;
  
  arg1 = (MakeOIS *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MakeOIS *) &(arg1)->withTelescopicValueDates(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeOIS_withAveragingMethod(void * jarg1, int jarg2) {
  void * jresult ;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  RateAveraging::Type arg2 ;
  MakeOIS *result = 0 ;
  
  arg1 = (MakeOIS *)jarg1; 
  arg2 = (RateAveraging::Type)jarg2; 
  {
    try {
      result = (MakeOIS *) &(arg1)->withAveragingMethod(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MakeOIS_withPricingEngine(void * jarg1, void * jarg2) {
  void * jresult ;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  ext::shared_ptr< PricingEngine > *arg2 = 0 ;
  ext::shared_ptr< PricingEngine > tempnull2 ;
  MakeOIS *result = 0 ;
  
  arg1 = (MakeOIS *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< PricingEngine > *)jarg2 : &tempnull2; 
  {
    try {
      result = (MakeOIS *) &(arg1)->withPricingEngine((ext::shared_ptr< PricingEngine > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwapIndex__SWIG_0(const char * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  Currency arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  bool arg6 ;
  RateAveraging::Type arg7 ;
  Currency *argp4 ;
  ext::shared_ptr< OvernightIndex > tempnull5 ;
  OvernightIndexedSwapIndex *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 & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  argp4 = (Currency *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Currency", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = jarg5 ? (ext::shared_ptr< OvernightIndex > *)jarg5 : &tempnull5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (RateAveraging::Type)jarg7; 
  {
    try {
      result = (OvernightIndexedSwapIndex *)new OvernightIndexedSwapIndex((std::string const &)*arg1,(Period const &)*arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OvernightIndexedSwapIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwapIndex__SWIG_1(const char * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5, unsigned int jarg6) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  Currency arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  bool arg6 ;
  Currency *argp4 ;
  ext::shared_ptr< OvernightIndex > tempnull5 ;
  OvernightIndexedSwapIndex *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 & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  argp4 = (Currency *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Currency", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = jarg5 ? (ext::shared_ptr< OvernightIndex > *)jarg5 : &tempnull5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (OvernightIndexedSwapIndex *)new OvernightIndexedSwapIndex((std::string const &)*arg1,(Period const &)*arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > 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 ? new ext::shared_ptr<  OvernightIndexedSwapIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexedSwapIndex__SWIG_2(const char * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  Currency arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Currency *argp4 ;
  ext::shared_ptr< OvernightIndex > tempnull5 ;
  OvernightIndexedSwapIndex *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 & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  argp4 = (Currency *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Currency", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = jarg5 ? (ext::shared_ptr< OvernightIndex > *)jarg5 : &tempnull5; 
  {
    try {
      result = (OvernightIndexedSwapIndex *)new OvernightIndexedSwapIndex((std::string const &)*arg1,(Period const &)*arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > 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 ? new ext::shared_ptr<  OvernightIndexedSwapIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwapIndex_overnightIndex(void * jarg1) {
  void * jresult ;
  OvernightIndexedSwapIndex *arg1 = (OvernightIndexedSwapIndex *) 0 ;
  ext::shared_ptr< OvernightIndexedSwapIndex const > *smartarg1 = 0 ;
  ext::shared_ptr< OvernightIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const OvernightIndexedSwapIndex > *)jarg1;
  arg1 = (OvernightIndexedSwapIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((OvernightIndexedSwapIndex const *)arg1)->overnightIndex();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< OvernightIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwapIndex_underlyingSwap(void * jarg1, void * jarg2) {
  void * jresult ;
  OvernightIndexedSwapIndex *arg1 = (OvernightIndexedSwapIndex *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< OvernightIndexedSwapIndex const > *smartarg1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > result;
  
  
  smartarg1 = (ext::shared_ptr< const OvernightIndexedSwapIndex > *)jarg1;
  arg1 = (OvernightIndexedSwapIndex *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((OvernightIndexedSwapIndex const *)arg1)->underlyingSwap((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 ? new ext::shared_ptr< OvernightIndexedSwap >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_OvernightIndexedSwapIndex(void * jarg1) {
  OvernightIndexedSwapIndex *arg1 = (OvernightIndexedSwapIndex *) 0 ;
  ext::shared_ptr< OvernightIndexedSwapIndex > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexedSwapIndex > *)jarg1;
  arg1 = (OvernightIndexedSwapIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_overnight_swap_index(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< InterestRateIndex > *arg1 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempnull1 ;
  ext::shared_ptr< OvernightIndexedSwap > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< InterestRateIndex > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_overnight_swap_index((ext::shared_ptr< InterestRateIndex > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< OvernightIndexedSwap >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCouponSwap__SWIG_0(int jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, void * jarg6, void * jarg7, int jarg8, unsigned int jarg9) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  ext::shared_ptr< IborIndex > arg6 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention arg8 ;
  Natural arg9 ;
  ZeroCouponSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  if (jarg6) arg6 = *(ext::shared_ptr< IborIndex > *)jarg6; 
  arg7 = (Calendar *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (Natural)jarg9; 
  {
    try {
      result = (ZeroCouponSwap *)new ZeroCouponSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,arg6,(Calendar 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 ? new ext::shared_ptr<  ZeroCouponSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCouponSwap__SWIG_1(int jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, void * jarg6, void * jarg7, int jarg8) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  ext::shared_ptr< IborIndex > arg6 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention arg8 ;
  ZeroCouponSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  if (jarg6) arg6 = *(ext::shared_ptr< IborIndex > *)jarg6; 
  arg7 = (Calendar *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg8 = (BusinessDayConvention)jarg8; 
  {
    try {
      result = (ZeroCouponSwap *)new ZeroCouponSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,arg6,(Calendar 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 ? new ext::shared_ptr<  ZeroCouponSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCouponSwap__SWIG_2(int jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  ext::shared_ptr< IborIndex > arg6 ;
  Calendar *arg7 = 0 ;
  ZeroCouponSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  if (jarg6) arg6 = *(ext::shared_ptr< IborIndex > *)jarg6; 
  arg7 = (Calendar *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroCouponSwap *)new ZeroCouponSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,arg6,(Calendar 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 ? new ext::shared_ptr<  ZeroCouponSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCouponSwap__SWIG_3(int jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, unsigned int jarg10) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Rate arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > arg7 ;
  Calendar *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  Natural arg10 ;
  ZeroCouponSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Rate)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  if (jarg7) arg7 = *(ext::shared_ptr< IborIndex > *)jarg7; 
  arg8 = (Calendar *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg9 = (BusinessDayConvention)jarg9; 
  arg10 = (Natural)jarg10; 
  {
    try {
      result = (ZeroCouponSwap *)new ZeroCouponSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,(Calendar 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 = result ? new ext::shared_ptr<  ZeroCouponSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCouponSwap__SWIG_4(int jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Rate arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > arg7 ;
  Calendar *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  ZeroCouponSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Rate)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  if (jarg7) arg7 = *(ext::shared_ptr< IborIndex > *)jarg7; 
  arg8 = (Calendar *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg9 = (BusinessDayConvention)jarg9; 
  {
    try {
      result = (ZeroCouponSwap *)new ZeroCouponSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,(Calendar 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 = result ? new ext::shared_ptr<  ZeroCouponSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroCouponSwap__SWIG_5(int jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Rate arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > arg7 ;
  Calendar *arg8 = 0 ;
  ZeroCouponSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Rate)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  if (jarg7) arg7 = *(ext::shared_ptr< IborIndex > *)jarg7; 
  arg8 = (Calendar *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroCouponSwap *)new ZeroCouponSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(DayCounter const &)*arg6,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 = result ? new ext::shared_ptr<  ZeroCouponSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_ZeroCouponSwap_type(void * jarg1) {
  int jresult ;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  Swap::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroCouponSwap > *)jarg1;
  arg1 = (ZeroCouponSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Swap::Type)((ZeroCouponSwap 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_ZeroCouponSwap_baseNominal(void * jarg1) {
  double jresult ;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroCouponSwap > *)jarg1;
  arg1 = (ZeroCouponSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZeroCouponSwap const *)arg1)->baseNominal();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroCouponSwap_iborIndex(void * jarg1) {
  void * jresult ;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  ext::shared_ptr< IborIndex > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroCouponSwap > *)jarg1;
  arg1 = (ZeroCouponSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (ext::shared_ptr< IborIndex > *) &((ZeroCouponSwap const *)arg1)->iborIndex();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = *result ? new ext::shared_ptr< IborIndex >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroCouponSwap_fixedLeg(void * jarg1) {
  void * jresult ;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroCouponSwap > *)jarg1;
  arg1 = (ZeroCouponSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &((ZeroCouponSwap const *)arg1)->fixedLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroCouponSwap_floatingLeg(void * jarg1) {
  void * jresult ;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroCouponSwap > *)jarg1;
  arg1 = (ZeroCouponSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &((ZeroCouponSwap const *)arg1)->floatingLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_ZeroCouponSwap_fixedPayment(void * jarg1) {
  double jresult ;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroCouponSwap > *)jarg1;
  arg1 = (ZeroCouponSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZeroCouponSwap const *)arg1)->fixedPayment();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroCouponSwap_fixedLegNPV(void * jarg1) {
  double jresult ;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroCouponSwap > *)jarg1;
  arg1 = (ZeroCouponSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZeroCouponSwap const *)arg1)->fixedLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroCouponSwap_floatingLegNPV(void * jarg1) {
  double jresult ;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroCouponSwap > *)jarg1;
  arg1 = (ZeroCouponSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZeroCouponSwap const *)arg1)->floatingLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroCouponSwap_fairFixedPayment(void * jarg1) {
  double jresult ;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroCouponSwap > *)jarg1;
  arg1 = (ZeroCouponSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZeroCouponSwap const *)arg1)->fairFixedPayment();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroCouponSwap_fairFixedRate(void * jarg1, void * jarg2) {
  double jresult ;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  DayCounter *arg2 = 0 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroCouponSwap > *)jarg1;
  arg1 = (ZeroCouponSwap *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)((ZeroCouponSwap const *)arg1)->fairFixedRate((DayCounter const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_ZeroCouponSwap(void * jarg1) {
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  ext::shared_ptr< ZeroCouponSwap > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZeroCouponSwap > *)jarg1;
  arg1 = (ZeroCouponSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EquityTotalReturnSwap__SWIG_0(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, void * jarg9, int jarg10, unsigned int jarg11) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< IborIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Real arg8 ;
  SwigValueWrapper< Calendar > arg9 ;
  BusinessDayConvention arg10 ;
  Natural arg11 ;
  Schedule *argp3 ;
  ext::shared_ptr< IborIndex > tempnull5 ;
  DayCounter *argp6 ;
  Calendar *argp9 ;
  EquityTotalReturnSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  argp3 = (Schedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Schedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  if (jarg4) arg4 = *(ext::shared_ptr< EquityIndex > *)jarg4; 
  arg5 = jarg5 ? (ext::shared_ptr< IborIndex > *)jarg5 : &tempnull5; 
  argp6 = (DayCounter *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg6 = *argp6; 
  arg7 = (Rate)jarg7; 
  arg8 = (Real)jarg8; 
  argp9 = (Calendar *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg9 = *argp9; 
  arg10 = (BusinessDayConvention)jarg10; 
  arg11 = (Natural)jarg11; 
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< IborIndex > const &)*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 ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EquityTotalReturnSwap__SWIG_1(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, void * jarg9, int jarg10) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< IborIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Real arg8 ;
  SwigValueWrapper< Calendar > arg9 ;
  BusinessDayConvention arg10 ;
  Schedule *argp3 ;
  ext::shared_ptr< IborIndex > tempnull5 ;
  DayCounter *argp6 ;
  Calendar *argp9 ;
  EquityTotalReturnSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  argp3 = (Schedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Schedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  if (jarg4) arg4 = *(ext::shared_ptr< EquityIndex > *)jarg4; 
  arg5 = jarg5 ? (ext::shared_ptr< IborIndex > *)jarg5 : &tempnull5; 
  argp6 = (DayCounter *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg6 = *argp6; 
  arg7 = (Rate)jarg7; 
  arg8 = (Real)jarg8; 
  argp9 = (Calendar *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg9 = *argp9; 
  arg10 = (BusinessDayConvention)jarg10; 
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< IborIndex > const &)*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 ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EquityTotalReturnSwap__SWIG_2(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, void * jarg9) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< IborIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Real arg8 ;
  SwigValueWrapper< Calendar > arg9 ;
  Schedule *argp3 ;
  ext::shared_ptr< IborIndex > tempnull5 ;
  DayCounter *argp6 ;
  Calendar *argp9 ;
  EquityTotalReturnSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  argp3 = (Schedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Schedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  if (jarg4) arg4 = *(ext::shared_ptr< EquityIndex > *)jarg4; 
  arg5 = jarg5 ? (ext::shared_ptr< IborIndex > *)jarg5 : &tempnull5; 
  argp6 = (DayCounter *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg6 = *argp6; 
  arg7 = (Rate)jarg7; 
  arg8 = (Real)jarg8; 
  argp9 = (Calendar *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg9 = *argp9; 
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EquityTotalReturnSwap__SWIG_3(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< IborIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Real arg8 ;
  Schedule *argp3 ;
  ext::shared_ptr< IborIndex > tempnull5 ;
  DayCounter *argp6 ;
  EquityTotalReturnSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  argp3 = (Schedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Schedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  if (jarg4) arg4 = *(ext::shared_ptr< EquityIndex > *)jarg4; 
  arg5 = jarg5 ? (ext::shared_ptr< IborIndex > *)jarg5 : &tempnull5; 
  argp6 = (DayCounter *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg6 = *argp6; 
  arg7 = (Rate)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EquityTotalReturnSwap__SWIG_4(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< IborIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Schedule *argp3 ;
  ext::shared_ptr< IborIndex > tempnull5 ;
  DayCounter *argp6 ;
  EquityTotalReturnSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  argp3 = (Schedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Schedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  if (jarg4) arg4 = *(ext::shared_ptr< EquityIndex > *)jarg4; 
  arg5 = jarg5 ? (ext::shared_ptr< IborIndex > *)jarg5 : &tempnull5; 
  argp6 = (DayCounter *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg6 = *argp6; 
  arg7 = (Rate)jarg7; 
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EquityTotalReturnSwap__SWIG_5(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, void * jarg9, int jarg10, unsigned int jarg11) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Real arg8 ;
  SwigValueWrapper< Calendar > arg9 ;
  BusinessDayConvention arg10 ;
  Natural arg11 ;
  Schedule *argp3 ;
  ext::shared_ptr< OvernightIndex > tempnull5 ;
  DayCounter *argp6 ;
  Calendar *argp9 ;
  EquityTotalReturnSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  argp3 = (Schedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Schedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  if (jarg4) arg4 = *(ext::shared_ptr< EquityIndex > *)jarg4; 
  arg5 = jarg5 ? (ext::shared_ptr< OvernightIndex > *)jarg5 : &tempnull5; 
  argp6 = (DayCounter *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg6 = *argp6; 
  arg7 = (Rate)jarg7; 
  arg8 = (Real)jarg8; 
  argp9 = (Calendar *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg9 = *argp9; 
  arg10 = (BusinessDayConvention)jarg10; 
  arg11 = (Natural)jarg11; 
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > const &)*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 ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EquityTotalReturnSwap__SWIG_6(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, void * jarg9, int jarg10) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Real arg8 ;
  SwigValueWrapper< Calendar > arg9 ;
  BusinessDayConvention arg10 ;
  Schedule *argp3 ;
  ext::shared_ptr< OvernightIndex > tempnull5 ;
  DayCounter *argp6 ;
  Calendar *argp9 ;
  EquityTotalReturnSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  argp3 = (Schedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Schedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  if (jarg4) arg4 = *(ext::shared_ptr< EquityIndex > *)jarg4; 
  arg5 = jarg5 ? (ext::shared_ptr< OvernightIndex > *)jarg5 : &tempnull5; 
  argp6 = (DayCounter *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg6 = *argp6; 
  arg7 = (Rate)jarg7; 
  arg8 = (Real)jarg8; 
  argp9 = (Calendar *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg9 = *argp9; 
  arg10 = (BusinessDayConvention)jarg10; 
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > const &)*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 ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EquityTotalReturnSwap__SWIG_7(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8, void * jarg9) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Real arg8 ;
  SwigValueWrapper< Calendar > arg9 ;
  Schedule *argp3 ;
  ext::shared_ptr< OvernightIndex > tempnull5 ;
  DayCounter *argp6 ;
  Calendar *argp9 ;
  EquityTotalReturnSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  argp3 = (Schedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Schedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  if (jarg4) arg4 = *(ext::shared_ptr< EquityIndex > *)jarg4; 
  arg5 = jarg5 ? (ext::shared_ptr< OvernightIndex > *)jarg5 : &tempnull5; 
  argp6 = (DayCounter *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg6 = *argp6; 
  arg7 = (Rate)jarg7; 
  arg8 = (Real)jarg8; 
  argp9 = (Calendar *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg9 = *argp9; 
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EquityTotalReturnSwap__SWIG_8(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7, double jarg8) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Real arg8 ;
  Schedule *argp3 ;
  ext::shared_ptr< OvernightIndex > tempnull5 ;
  DayCounter *argp6 ;
  EquityTotalReturnSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  argp3 = (Schedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Schedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  if (jarg4) arg4 = *(ext::shared_ptr< EquityIndex > *)jarg4; 
  arg5 = jarg5 ? (ext::shared_ptr< OvernightIndex > *)jarg5 : &tempnull5; 
  argp6 = (DayCounter *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg6 = *argp6; 
  arg7 = (Rate)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EquityTotalReturnSwap__SWIG_9(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, double jarg7) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Schedule *argp3 ;
  ext::shared_ptr< OvernightIndex > tempnull5 ;
  DayCounter *argp6 ;
  EquityTotalReturnSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  argp3 = (Schedule *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Schedule", 0);
    return 0;
  }
  arg3 = *argp3; 
  if (jarg4) arg4 = *(ext::shared_ptr< EquityIndex > *)jarg4; 
  arg5 = jarg5 ? (ext::shared_ptr< OvernightIndex > *)jarg5 : &tempnull5; 
  argp6 = (DayCounter *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg6 = *argp6; 
  arg7 = (Rate)jarg7; 
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_EquityTotalReturnSwap_type(void * jarg1) {
  int jresult ;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  Swap::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Swap::Type)((EquityTotalReturnSwap 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_EquityTotalReturnSwap_nominal(void * jarg1) {
  double jresult ;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((EquityTotalReturnSwap const *)arg1)->nominal();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_EquityTotalReturnSwap_equityIndex(void * jarg1) {
  void * jresult ;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  ext::shared_ptr< EquityIndex > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (ext::shared_ptr< EquityIndex > *) &((EquityTotalReturnSwap const *)arg1)->equityIndex();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = *result ? new ext::shared_ptr< EquityIndex >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_EquityTotalReturnSwap_interestRateIndex(void * jarg1) {
  void * jresult ;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  ext::shared_ptr< InterestRateIndex > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (ext::shared_ptr< InterestRateIndex > *) &((EquityTotalReturnSwap const *)arg1)->interestRateIndex();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = *result ? new ext::shared_ptr< InterestRateIndex >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_EquityTotalReturnSwap_schedule(void * jarg1) {
  void * jresult ;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  Schedule *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Schedule *) &((EquityTotalReturnSwap const *)arg1)->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 void * SWIGSTDCALL CSharp_QuantLib_EquityTotalReturnSwap_dayCounter(void * jarg1) {
  void * jresult ;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  DayCounter *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (DayCounter *) &((EquityTotalReturnSwap 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_EquityTotalReturnSwap_margin(void * jarg1) {
  double jresult ;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((EquityTotalReturnSwap const *)arg1)->margin();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_EquityTotalReturnSwap_gearing(void * jarg1) {
  double jresult ;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((EquityTotalReturnSwap const *)arg1)->gearing();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_EquityTotalReturnSwap_paymentCalendar(void * jarg1) {
  void * jresult ;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  Calendar *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Calendar *) &((EquityTotalReturnSwap const *)arg1)->paymentCalendar();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_EquityTotalReturnSwap_paymentConvention(void * jarg1) {
  int jresult ;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  BusinessDayConvention result;
  
  
  smartarg1 = (ext::shared_ptr< const EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (BusinessDayConvention)((EquityTotalReturnSwap const *)arg1)->paymentConvention();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_EquityTotalReturnSwap_paymentDelay(void * jarg1) {
  unsigned int jresult ;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  Natural result;
  
  
  smartarg1 = (ext::shared_ptr< const EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Natural)((EquityTotalReturnSwap const *)arg1)->paymentDelay();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_EquityTotalReturnSwap_equityLeg(void * jarg1) {
  void * jresult ;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &((EquityTotalReturnSwap const *)arg1)->equityLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_EquityTotalReturnSwap_interestRateLeg(void * jarg1) {
  void * jresult ;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &((EquityTotalReturnSwap const *)arg1)->interestRateLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_EquityTotalReturnSwap_equityLegNPV(void * jarg1) {
  double jresult ;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((EquityTotalReturnSwap const *)arg1)->equityLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_EquityTotalReturnSwap_interestRateLegNPV(void * jarg1) {
  double jresult ;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((EquityTotalReturnSwap const *)arg1)->interestRateLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_EquityTotalReturnSwap_fairMargin(void * jarg1) {
  double jresult ;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((EquityTotalReturnSwap const *)arg1)->fairMargin();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_EquityTotalReturnSwap(void * jarg1) {
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  ext::shared_ptr< EquityTotalReturnSwap > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EquityTotalReturnSwap > *)jarg1;
  arg1 = (EquityTotalReturnSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ArithmeticAverageOIS__SWIG_0(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  Spread arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  DayCounter *argp5 ;
  ArithmeticAverageOIS *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  argp5 = (DayCounter *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg5 = *argp5; 
  if (jarg6) arg6 = *(ext::shared_ptr< OvernightIndex > *)jarg6; 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = (Spread)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule const &)*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 ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ArithmeticAverageOIS__SWIG_1(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, double jarg8, double jarg9, double jarg10) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  Spread arg8 ;
  Real arg9 ;
  Real arg10 ;
  DayCounter *argp5 ;
  ArithmeticAverageOIS *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  argp5 = (DayCounter *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg5 = *argp5; 
  if (jarg6) arg6 = *(ext::shared_ptr< OvernightIndex > *)jarg6; 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = (Spread)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule 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 ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ArithmeticAverageOIS__SWIG_2(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, double jarg8, double jarg9) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  Spread arg8 ;
  Real arg9 ;
  DayCounter *argp5 ;
  ArithmeticAverageOIS *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  argp5 = (DayCounter *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg5 = *argp5; 
  if (jarg6) arg6 = *(ext::shared_ptr< OvernightIndex > *)jarg6; 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = (Spread)jarg8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule 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 ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ArithmeticAverageOIS__SWIG_3(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, double jarg8) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  Spread arg8 ;
  DayCounter *argp5 ;
  ArithmeticAverageOIS *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  argp5 = (DayCounter *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg5 = *argp5; 
  if (jarg6) arg6 = *(ext::shared_ptr< OvernightIndex > *)jarg6; 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = (Spread)jarg8; 
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule 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 ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ArithmeticAverageOIS__SWIG_4(int jarg1, double jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  DayCounter *argp5 ;
  ArithmeticAverageOIS *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  argp5 = (DayCounter *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg5 = *argp5; 
  if (jarg6) arg6 = *(ext::shared_ptr< OvernightIndex > *)jarg6; 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule 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 ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ArithmeticAverageOIS__SWIG_5(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, double jarg8, double jarg9, double jarg10, unsigned int jarg11) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  Spread arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  std::vector< Real > *argp2 ;
  DayCounter *argp5 ;
  ArithmeticAverageOIS *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  argp2 = (std::vector< Real > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  argp5 = (DayCounter *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg5 = *argp5; 
  if (jarg6) arg6 = *(ext::shared_ptr< OvernightIndex > *)jarg6; 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = (Spread)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule const &)*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 ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ArithmeticAverageOIS__SWIG_6(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, double jarg8, double jarg9, double jarg10) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  Spread arg8 ;
  Real arg9 ;
  Real arg10 ;
  std::vector< Real > *argp2 ;
  DayCounter *argp5 ;
  ArithmeticAverageOIS *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  argp2 = (std::vector< Real > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  argp5 = (DayCounter *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg5 = *argp5; 
  if (jarg6) arg6 = *(ext::shared_ptr< OvernightIndex > *)jarg6; 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = (Spread)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule 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 ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ArithmeticAverageOIS__SWIG_7(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, double jarg8, double jarg9) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  Spread arg8 ;
  Real arg9 ;
  std::vector< Real > *argp2 ;
  DayCounter *argp5 ;
  ArithmeticAverageOIS *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  argp2 = (std::vector< Real > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  argp5 = (DayCounter *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg5 = *argp5; 
  if (jarg6) arg6 = *(ext::shared_ptr< OvernightIndex > *)jarg6; 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = (Spread)jarg8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule 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 ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ArithmeticAverageOIS__SWIG_8(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, double jarg8) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  Spread arg8 ;
  std::vector< Real > *argp2 ;
  DayCounter *argp5 ;
  ArithmeticAverageOIS *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  argp2 = (std::vector< Real > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  argp5 = (DayCounter *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg5 = *argp5; 
  if (jarg6) arg6 = *(ext::shared_ptr< OvernightIndex > *)jarg6; 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = (Spread)jarg8; 
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule 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 ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ArithmeticAverageOIS__SWIG_9(int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Swap::Type arg1 ;
  std::vector< Real > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  std::vector< Real > *argp2 ;
  DayCounter *argp5 ;
  ArithmeticAverageOIS *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  argp2 = (std::vector< Real > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  argp5 = (DayCounter *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg5 = *argp5; 
  if (jarg6) arg6 = *(ext::shared_ptr< OvernightIndex > *)jarg6; 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule 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 ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_ArithmeticAverageOIS_type(void * jarg1) {
  int jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  Swap::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Swap::Type)((ArithmeticAverageOIS 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_ArithmeticAverageOIS_nominal(void * jarg1) {
  double jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ArithmeticAverageOIS const *)arg1)->nominal();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ArithmeticAverageOIS_nominals(void * jarg1) {
  void * jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  std::vector< Real > result;
  
  
  smartarg1 = (ext::shared_ptr< const ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((ArithmeticAverageOIS const *)arg1)->nominals();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_ArithmeticAverageOIS_fixedLegPaymentFrequency(void * jarg1) {
  int jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS > *smartarg1 = 0 ;
  Frequency result;
  
  
  smartarg1 = (ext::shared_ptr<  ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Frequency)(arg1)->fixedLegPaymentFrequency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_ArithmeticAverageOIS_overnightLegPaymentFrequency(void * jarg1) {
  int jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS > *smartarg1 = 0 ;
  Frequency result;
  
  
  smartarg1 = (ext::shared_ptr<  ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Frequency)(arg1)->overnightLegPaymentFrequency();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_ArithmeticAverageOIS_fixedRate(void * jarg1) {
  double jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((ArithmeticAverageOIS const *)arg1)->fixedRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ArithmeticAverageOIS_fixedDayCount(void * jarg1) {
  void * jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS > *smartarg1 = 0 ;
  DayCounter *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (DayCounter *) &(arg1)->fixedDayCount();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ArithmeticAverageOIS_overnightIndex(void * jarg1) {
  void * jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS > *smartarg1 = 0 ;
  ext::shared_ptr< OvernightIndex > result;
  
  
  smartarg1 = (ext::shared_ptr<  ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->overnightIndex();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< OvernightIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ArithmeticAverageOIS_spread(void * jarg1) {
  double jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  Spread result;
  
  
  smartarg1 = (ext::shared_ptr< const ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Spread)((ArithmeticAverageOIS const *)arg1)->spread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ArithmeticAverageOIS_fixedLeg(void * jarg1) {
  void * jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &((ArithmeticAverageOIS const *)arg1)->fixedLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ArithmeticAverageOIS_overnightLeg(void * jarg1) {
  void * jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &((ArithmeticAverageOIS const *)arg1)->overnightLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_ArithmeticAverageOIS_fixedLegBPS(void * jarg1) {
  double jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ArithmeticAverageOIS const *)arg1)->fixedLegBPS();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ArithmeticAverageOIS_fixedLegNPV(void * jarg1) {
  double jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ArithmeticAverageOIS const *)arg1)->fixedLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ArithmeticAverageOIS_fairRate(void * jarg1) {
  double jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ArithmeticAverageOIS const *)arg1)->fairRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ArithmeticAverageOIS_overnightLegBPS(void * jarg1) {
  double jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ArithmeticAverageOIS const *)arg1)->overnightLegBPS();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ArithmeticAverageOIS_overnightLegNPV(void * jarg1) {
  double jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ArithmeticAverageOIS const *)arg1)->overnightLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ArithmeticAverageOIS_fairSpread(void * jarg1) {
  double jresult ;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  Spread result;
  
  
  smartarg1 = (ext::shared_ptr< const ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Spread)((ArithmeticAverageOIS const *)arg1)->fairSpread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_ArithmeticAverageOIS(void * jarg1) {
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  ext::shared_ptr< ArithmeticAverageOIS > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ArithmeticAverageOIS > *)jarg1;
  arg1 = (ArithmeticAverageOIS *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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 ;
  Seasonality *arg1 = (Seasonality *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  InflationTermStructure *arg4 = 0 ;
  ext::shared_ptr< Seasonality const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const Seasonality > *)jarg1;
  arg1 = (Seasonality *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (InflationTermStructure *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InflationTermStructure const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)((Seasonality const *)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 ;
  Seasonality *arg1 = (Seasonality *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  InflationTermStructure *arg4 = 0 ;
  ext::shared_ptr< Seasonality const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const Seasonality > *)jarg1;
  arg1 = (Seasonality *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  arg4 = (InflationTermStructure *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InflationTermStructure const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)((Seasonality const *)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 ;
  Seasonality *arg1 = (Seasonality *) 0 ;
  InflationTermStructure *arg2 = 0 ;
  ext::shared_ptr< Seasonality > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr<  Seasonality > *)jarg1;
  arg1 = (Seasonality *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (InflationTermStructure *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InflationTermStructure const & 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_delete_Seasonality(void * jarg1) {
  Seasonality *arg1 = (Seasonality *) 0 ;
  ext::shared_ptr< Seasonality > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Seasonality > *)jarg1;
  arg1 = (Seasonality *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MultiplicativePriceSeasonality(void * jarg1, int jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  Frequency arg2 ;
  std::vector< Rate > *arg3 = 0 ;
  MultiplicativePriceSeasonality *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Frequency)jarg2; 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MultiplicativePriceSeasonality *)new MultiplicativePriceSeasonality((Date const &)*arg1,arg2,(std::vector< Rate > 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 ? new ext::shared_ptr<  MultiplicativePriceSeasonality >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MultiplicativePriceSeasonality(void * jarg1) {
  MultiplicativePriceSeasonality *arg1 = (MultiplicativePriceSeasonality *) 0 ;
  ext::shared_ptr< MultiplicativePriceSeasonality > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MultiplicativePriceSeasonality > *)jarg1;
  arg1 = (MultiplicativePriceSeasonality *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KerkhofSeasonality(void * jarg1, void * jarg2) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  KerkhofSeasonality *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (KerkhofSeasonality *)new KerkhofSeasonality((Date const &)*arg1,(std::vector< Rate > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  KerkhofSeasonality >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_KerkhofSeasonality(void * jarg1) {
  KerkhofSeasonality *arg1 = (KerkhofSeasonality *) 0 ;
  ext::shared_ptr< KerkhofSeasonality > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  KerkhofSeasonality > *)jarg1;
  arg1 = (KerkhofSeasonality *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InflationTermStructure_observationLag(void * jarg1) {
  void * jresult ;
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  ext::shared_ptr< InflationTermStructure const > *smartarg1 = 0 ;
  Period result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationTermStructure > *)jarg1;
  arg1 = (InflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InflationTermStructure const *)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(result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_InflationTermStructure_frequency(void * jarg1) {
  int jresult ;
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  ext::shared_ptr< InflationTermStructure const > *smartarg1 = 0 ;
  Frequency result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationTermStructure > *)jarg1;
  arg1 = (InflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Frequency)((InflationTermStructure 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_InflationTermStructure_baseRate(void * jarg1) {
  double jresult ;
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  ext::shared_ptr< InflationTermStructure const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationTermStructure > *)jarg1;
  arg1 = (InflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((InflationTermStructure const *)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_InflationTermStructure_baseDate(void * jarg1) {
  void * jresult ;
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  ext::shared_ptr< InflationTermStructure const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationTermStructure > *)jarg1;
  arg1 = (InflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InflationTermStructure const *)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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_InflationTermStructure_setSeasonality__SWIG_0(void * jarg1, void * jarg2) {
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  ext::shared_ptr< Seasonality > *arg2 = 0 ;
  ext::shared_ptr< InflationTermStructure > *smartarg1 = 0 ;
  ext::shared_ptr< Seasonality > tempnull2 ;
  
  
  smartarg1 = (ext::shared_ptr<  InflationTermStructure > *)jarg1;
  arg1 = (InflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (ext::shared_ptr< Seasonality > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->setSeasonality((ext::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_InflationTermStructure_setSeasonality__SWIG_1(void * jarg1) {
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  ext::shared_ptr< InflationTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InflationTermStructure > *)jarg1;
  arg1 = (InflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_InflationTermStructure_seasonality(void * jarg1) {
  void * jresult ;
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  ext::shared_ptr< InflationTermStructure const > *smartarg1 = 0 ;
  ext::shared_ptr< Seasonality > result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationTermStructure > *)jarg1;
  arg1 = (InflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InflationTermStructure const *)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 = result ? new ext::shared_ptr< Seasonality >(result) : 0; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_InflationTermStructure_hasSeasonality(void * jarg1) {
  unsigned int jresult ;
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  ext::shared_ptr< InflationTermStructure const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationTermStructure > *)jarg1;
  arg1 = (InflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((InflationTermStructure const *)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_delete_InflationTermStructure(void * jarg1) {
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  ext::shared_ptr< InflationTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InflationTermStructure > *)jarg1;
  arg1 = (InflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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 ;
  YoYInflationTermStructure *arg1 = (YoYInflationTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< YoYInflationTermStructure const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationTermStructure > *)jarg1;
  arg1 = (YoYInflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Rate)((YoYInflationTermStructure const *)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 ;
  YoYInflationTermStructure *arg1 = (YoYInflationTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< YoYInflationTermStructure const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationTermStructure > *)jarg1;
  arg1 = (YoYInflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Rate)((YoYInflationTermStructure const *)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 ;
  YoYInflationTermStructure *arg1 = (YoYInflationTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationTermStructure > *)jarg1;
  arg1 = (YoYInflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)((YoYInflationTermStructure const *)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 ;
  YoYInflationTermStructure *arg1 = (YoYInflationTermStructure *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationTermStructure > *)jarg1;
  arg1 = (YoYInflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)((YoYInflationTermStructure const *)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 double SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_yoyRate__SWIG_4(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  YoYInflationTermStructure *arg1 = (YoYInflationTermStructure *) 0 ;
  Time arg2 ;
  bool arg3 ;
  ext::shared_ptr< YoYInflationTermStructure const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationTermStructure > *)jarg1;
  arg1 = (YoYInflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Rate)((YoYInflationTermStructure const *)arg1)->yoyRate(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_YoYInflationTermStructure_yoyRate__SWIG_5(void * jarg1, double jarg2) {
  double jresult ;
  YoYInflationTermStructure *arg1 = (YoYInflationTermStructure *) 0 ;
  Time arg2 ;
  ext::shared_ptr< YoYInflationTermStructure const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationTermStructure > *)jarg1;
  arg1 = (YoYInflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Rate)((YoYInflationTermStructure const *)arg1)->yoyRate(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_YoYInflationTermStructure_indexIsInterpolated(void * jarg1) {
  unsigned int jresult ;
  YoYInflationTermStructure *arg1 = (YoYInflationTermStructure *) 0 ;
  ext::shared_ptr< YoYInflationTermStructure const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationTermStructure > *)jarg1;
  arg1 = (YoYInflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((YoYInflationTermStructure const *)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 void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationTermStructure(void * jarg1) {
  YoYInflationTermStructure *arg1 = (YoYInflationTermStructure *) 0 ;
  ext::shared_ptr< YoYInflationTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YoYInflationTermStructure > *)jarg1;
  arg1 = (YoYInflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< YoYInflationTermStructure > *arg1 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure > tempnull1 ;
  Handle< YoYInflationTermStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< YoYInflationTermStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Handle< YoYInflationTermStructure > *)new Handle< YoYInflationTermStructure >((ext::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 ;
  ext::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 = result ? new ext::shared_ptr< YoYInflationTermStructure >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_currentLink(void * jarg1) {
  void * jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  ext::shared_ptr< YoYInflationTermStructure > result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< YoYInflationTermStructure >(result) : 0; 
  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 ;
  ext::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 = result ? new ext::shared_ptr< Observable >(result) : 0; 
  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 & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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 & 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 double SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_yoyRate__SWIG_4(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  Rate result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Rate)(*arg1)->yoyRate(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_YoYInflationTermStructureHandle_yoyRate__SWIG_5(void * jarg1, double jarg2) {
  double jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Time arg2 ;
  Rate result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Rate)(*arg1)->yoyRate(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_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 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(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 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_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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_setSeasonality__SWIG_0(void * jarg1, void * jarg2) {
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  ext::shared_ptr< Seasonality > *arg2 = 0 ;
  ext::shared_ptr< Seasonality > tempnull2 ;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Seasonality > *)jarg2 : &tempnull2; 
  {
    try {
      (*arg1)->setSeasonality((ext::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 ;
  ext::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 = result ? new ext::shared_ptr< Seasonality >(result) : 0; 
  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_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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructureHandle_timeFromReference(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time result;
  
  arg1 = (Handle< YoYInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)(*arg1)->timeFromReference((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_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(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(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(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_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 ;
  ext::shared_ptr< YoYInflationTermStructure > *arg1 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure > tempnull1 ;
  RelinkableHandle< YoYInflationTermStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< YoYInflationTermStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (RelinkableHandle< YoYInflationTermStructure > *)new RelinkableHandle< YoYInflationTermStructure >((ext::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 ;
  ext::shared_ptr< YoYInflationTermStructure > *arg2 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure > tempnull2 ;
  
  arg1 = (RelinkableHandle< YoYInflationTermStructure > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< YoYInflationTermStructure > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->linkTo((ext::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_RelinkableYoYInflationTermStructureHandle_reset(void * jarg1) {
  RelinkableHandle< YoYInflationTermStructure > *arg1 = (RelinkableHandle< YoYInflationTermStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< YoYInflationTermStructure > *)jarg1; 
  {
    try {
      RelinkableHandle_Sl_YoYInflationTermStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_zeroRate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, unsigned int jarg5) {
  double jresult ;
  ZeroInflationTermStructure *arg1 = (ZeroInflationTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< ZeroInflationTermStructure const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroInflationTermStructure > *)jarg1;
  arg1 = (ZeroInflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Rate)((ZeroInflationTermStructure const *)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 ;
  ZeroInflationTermStructure *arg1 = (ZeroInflationTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< ZeroInflationTermStructure const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroInflationTermStructure > *)jarg1;
  arg1 = (ZeroInflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Rate)((ZeroInflationTermStructure const *)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 ;
  ZeroInflationTermStructure *arg1 = (ZeroInflationTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< ZeroInflationTermStructure const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroInflationTermStructure > *)jarg1;
  arg1 = (ZeroInflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)((ZeroInflationTermStructure const *)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 ;
  ZeroInflationTermStructure *arg1 = (ZeroInflationTermStructure *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationTermStructure const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroInflationTermStructure > *)jarg1;
  arg1 = (ZeroInflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)((ZeroInflationTermStructure const *)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 double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_zeroRate__SWIG_4(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  ZeroInflationTermStructure *arg1 = (ZeroInflationTermStructure *) 0 ;
  Time arg2 ;
  bool arg3 ;
  ext::shared_ptr< ZeroInflationTermStructure const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroInflationTermStructure > *)jarg1;
  arg1 = (ZeroInflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Rate)((ZeroInflationTermStructure const *)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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_zeroRate__SWIG_5(void * jarg1, double jarg2) {
  double jresult ;
  ZeroInflationTermStructure *arg1 = (ZeroInflationTermStructure *) 0 ;
  Time arg2 ;
  ext::shared_ptr< ZeroInflationTermStructure const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroInflationTermStructure > *)jarg1;
  arg1 = (ZeroInflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Rate)((ZeroInflationTermStructure const *)arg1)->zeroRate(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_ZeroInflationTermStructure(void * jarg1) {
  ZeroInflationTermStructure *arg1 = (ZeroInflationTermStructure *) 0 ;
  ext::shared_ptr< ZeroInflationTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZeroInflationTermStructure > *)jarg1;
  arg1 = (ZeroInflationTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroInflationTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< ZeroInflationTermStructure > *arg1 = 0 ;
  ext::shared_ptr< ZeroInflationTermStructure > tempnull1 ;
  Handle< ZeroInflationTermStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ZeroInflationTermStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Handle< ZeroInflationTermStructure > *)new Handle< ZeroInflationTermStructure >((ext::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 ;
  ext::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 = result ? new ext::shared_ptr< ZeroInflationTermStructure >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_currentLink(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  ext::shared_ptr< ZeroInflationTermStructure > result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< ZeroInflationTermStructure >(result) : 0; 
  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 ;
  ext::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 = result ? new ext::shared_ptr< Observable >(result) : 0; 
  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 & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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 & 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 double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_zeroRate__SWIG_4(void * jarg1, double jarg2, unsigned int jarg3) {
  double jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  Rate result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Rate)(*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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_zeroRate__SWIG_5(void * jarg1, double jarg2) {
  double jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Time arg2 ;
  Rate result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Rate)(*arg1)->zeroRate(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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(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 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_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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_setSeasonality__SWIG_0(void * jarg1, void * jarg2) {
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  ext::shared_ptr< Seasonality > *arg2 = 0 ;
  ext::shared_ptr< Seasonality > tempnull2 ;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Seasonality > *)jarg2 : &tempnull2; 
  {
    try {
      (*arg1)->setSeasonality((ext::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 ;
  ext::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 = result ? new ext::shared_ptr< Seasonality >(result) : 0; 
  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_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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructureHandle_timeFromReference(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time result;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)(*arg1)->timeFromReference((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_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(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(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(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_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 ;
  ext::shared_ptr< ZeroInflationTermStructure > *arg1 = 0 ;
  ext::shared_ptr< ZeroInflationTermStructure > tempnull1 ;
  RelinkableHandle< ZeroInflationTermStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ZeroInflationTermStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (RelinkableHandle< ZeroInflationTermStructure > *)new RelinkableHandle< ZeroInflationTermStructure >((ext::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 ;
  ext::shared_ptr< ZeroInflationTermStructure > *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationTermStructure > tempnull2 ;
  
  arg1 = (RelinkableHandle< ZeroInflationTermStructure > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< ZeroInflationTermStructure > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->linkTo((ext::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_RelinkableZeroInflationTermStructureHandle_reset(void * jarg1) {
  RelinkableHandle< ZeroInflationTermStructure > *arg1 = (RelinkableHandle< ZeroInflationTermStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< ZeroInflationTermStructure > *)jarg1; 
  {
    try {
      RelinkableHandle_Sl_ZeroInflationTermStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 const char * SWIGSTDCALL CSharp_QuantLib_Region_name(void * jarg1) {
  const 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 const char * SWIGSTDCALL CSharp_QuantLib_Region_code(void * jarg1) {
  const 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(const char * jarg1, const 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 const char * SWIGSTDCALL CSharp_QuantLib_InflationIndex_familyName(void * jarg1) {
  const char * jresult ;
  InflationIndex *arg1 = (InflationIndex *) 0 ;
  ext::shared_ptr< InflationIndex const > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationIndex > *)jarg1;
  arg1 = (InflationIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InflationIndex const *)arg1)->familyName();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_InflationIndex_region(void * jarg1) {
  void * jresult ;
  InflationIndex *arg1 = (InflationIndex *) 0 ;
  ext::shared_ptr< InflationIndex const > *smartarg1 = 0 ;
  SwigValueWrapper< Region > result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationIndex > *)jarg1;
  arg1 = (InflationIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InflationIndex const *)arg1)->region();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new Region(result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_InflationIndex_revised(void * jarg1) {
  unsigned int jresult ;
  InflationIndex *arg1 = (InflationIndex *) 0 ;
  ext::shared_ptr< InflationIndex const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationIndex > *)jarg1;
  arg1 = (InflationIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((InflationIndex const *)arg1)->revised();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_InflationIndex_interpolated(void * jarg1) {
  unsigned int jresult ;
  InflationIndex *arg1 = (InflationIndex *) 0 ;
  ext::shared_ptr< InflationIndex const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationIndex > *)jarg1;
  arg1 = (InflationIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((InflationIndex const *)arg1)->interpolated();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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 ;
  InflationIndex *arg1 = (InflationIndex *) 0 ;
  ext::shared_ptr< InflationIndex const > *smartarg1 = 0 ;
  Frequency result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationIndex > *)jarg1;
  arg1 = (InflationIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Frequency)((InflationIndex 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_InflationIndex_availabilityLag(void * jarg1) {
  void * jresult ;
  InflationIndex *arg1 = (InflationIndex *) 0 ;
  ext::shared_ptr< InflationIndex const > *smartarg1 = 0 ;
  Period result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationIndex > *)jarg1;
  arg1 = (InflationIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InflationIndex const *)arg1)->availabilityLag();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InflationIndex_currency(void * jarg1) {
  void * jresult ;
  InflationIndex *arg1 = (InflationIndex *) 0 ;
  ext::shared_ptr< InflationIndex const > *smartarg1 = 0 ;
  Currency result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationIndex > *)jarg1;
  arg1 = (InflationIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InflationIndex 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 = new Currency(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InflationIndex(void * jarg1) {
  InflationIndex *arg1 = (InflationIndex *) 0 ;
  ext::shared_ptr< InflationIndex > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InflationIndex > *)jarg1;
  arg1 = (InflationIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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(const char * jarg1, void * jarg2, unsigned int jarg3, int jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Region *arg2 = 0 ;
  bool arg3 ;
  Frequency arg4 ;
  Period *arg5 = 0 ;
  Currency *arg6 = 0 ;
  Handle< ZeroInflationTermStructure > *arg7 = 0 ;
  ZeroInflationIndex *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 & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (Currency *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  arg7 = (Handle< ZeroInflationTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroInflationIndex *)new ZeroInflationIndex((std::string const &)*arg1,(Region const &)*arg2,arg3,arg4,(Period const &)*arg5,(Currency const &)*arg6,(Handle< ZeroInflationTermStructure > 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 ? new ext::shared_ptr<  ZeroInflationIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroInflationIndex__SWIG_1(const char * jarg1, void * jarg2, unsigned int jarg3, int jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Region *arg2 = 0 ;
  bool arg3 ;
  Frequency arg4 ;
  Period *arg5 = 0 ;
  Currency *arg6 = 0 ;
  ZeroInflationIndex *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 & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (Currency *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroInflationIndex *)new ZeroInflationIndex((std::string const &)*arg1,(Region const &)*arg2,arg3,arg4,(Period const &)*arg5,(Currency 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 ? new ext::shared_ptr<  ZeroInflationIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroInflationIndex__SWIG_2(const 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 ;
  ZeroInflationIndex *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 & 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 & is null", 0);
    return 0;
  } 
  arg7 = (Currency *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< ZeroInflationTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroInflationIndex *)new ZeroInflationIndex((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 = result ? new ext::shared_ptr<  ZeroInflationIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroInflationIndex__SWIG_3(const 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 ;
  ZeroInflationIndex *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 & 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 & is null", 0);
    return 0;
  } 
  arg7 = (Currency *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroInflationIndex *)new ZeroInflationIndex((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 = result ? new ext::shared_ptr<  ZeroInflationIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationIndex_zeroInflationTermStructure(void * jarg1) {
  void * jresult ;
  ZeroInflationIndex *arg1 = (ZeroInflationIndex *) 0 ;
  ext::shared_ptr< ZeroInflationIndex const > *smartarg1 = 0 ;
  Handle< ZeroInflationTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroInflationIndex > *)jarg1;
  arg1 = (ZeroInflationIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((ZeroInflationIndex const *)arg1)->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 = new Handle< ZeroInflationTermStructure >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationIndex_clone(void * jarg1, void * jarg2) {
  void * jresult ;
  ZeroInflationIndex *arg1 = (ZeroInflationIndex *) 0 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex const > *smartarg1 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroInflationIndex > *)jarg1;
  arg1 = (ZeroInflationIndex *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Handle< ZeroInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((ZeroInflationIndex const *)arg1)->clone((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 = result ? new ext::shared_ptr< ZeroInflationIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroInflationIndex(void * jarg1) {
  ZeroInflationIndex *arg1 = (ZeroInflationIndex *) 0 ;
  ext::shared_ptr< ZeroInflationIndex > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZeroInflationIndex > *)jarg1;
  arg1 = (ZeroInflationIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_zero_inflation_index(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< Index > *arg1 = 0 ;
  ext::shared_ptr< Index > tempnull1 ;
  ext::shared_ptr< ZeroInflationIndex > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< Index > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_zero_inflation_index((ext::shared_ptr< Index > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< ZeroInflationIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationIndex__SWIG_0(void * jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< ZeroInflationIndex > *arg1 = 0 ;
  bool arg2 ;
  Handle< YoYInflationTermStructure > arg3 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull1 ;
  Handle< YoYInflationTermStructure > *argp3 ;
  YoYInflationIndex *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  argp3 = (Handle< YoYInflationTermStructure > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YoYInflationTermStructure >", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (YoYInflationIndex *)new YoYInflationIndex((ext::shared_ptr< ZeroInflationIndex > 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 ? new ext::shared_ptr<  YoYInflationIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationIndex__SWIG_1(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  ext::shared_ptr< ZeroInflationIndex > *arg1 = 0 ;
  bool arg2 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull1 ;
  YoYInflationIndex *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (YoYInflationIndex *)new YoYInflationIndex((ext::shared_ptr< ZeroInflationIndex > 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 ? new ext::shared_ptr<  YoYInflationIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationIndex__SWIG_2(const 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< YoYInflationTermStructure > arg8 ;
  Handle< YoYInflationTermStructure > *argp8 ;
  YoYInflationIndex *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 & 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 & is null", 0);
    return 0;
  } 
  arg7 = (Currency *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  argp8 = (Handle< YoYInflationTermStructure > *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YoYInflationTermStructure >", 0);
    return 0;
  }
  arg8 = *argp8; 
  {
    try {
      result = (YoYInflationIndex *)new YoYInflationIndex((std::string const &)*arg1,(Region const &)*arg2,arg3,arg4,arg5,(Period const &)*arg6,(Currency 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 ? new ext::shared_ptr<  YoYInflationIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationIndex__SWIG_3(const 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 ;
  YoYInflationIndex *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 & 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 & is null", 0);
    return 0;
  } 
  arg7 = (Currency *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationIndex *)new YoYInflationIndex((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 = result ? new ext::shared_ptr<  YoYInflationIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationIndex__SWIG_4(const char * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, void * jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Region *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  Frequency arg6 ;
  Period *arg7 = 0 ;
  Currency *arg8 = 0 ;
  Handle< YoYInflationTermStructure > *arg9 = 0 ;
  YoYInflationIndex *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 & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (Frequency)jarg6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (Currency *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  arg9 = (Handle< YoYInflationTermStructure > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationIndex *)new YoYInflationIndex((std::string const &)*arg1,(Region const &)*arg2,arg3,arg4,arg5,arg6,(Period const &)*arg7,(Currency const &)*arg8,(Handle< YoYInflationTermStructure > 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 ? new ext::shared_ptr<  YoYInflationIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationIndex__SWIG_5(const char * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, int jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Region *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  Frequency arg6 ;
  Period *arg7 = 0 ;
  Currency *arg8 = 0 ;
  YoYInflationIndex *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 & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  arg6 = (Frequency)jarg6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (Currency *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationIndex *)new YoYInflationIndex((std::string const &)*arg1,(Region const &)*arg2,arg3,arg4,arg5,arg6,(Period const &)*arg7,(Currency 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 ? new ext::shared_ptr<  YoYInflationIndex >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YoYInflationIndex_ratio(void * jarg1) {
  unsigned int jresult ;
  YoYInflationIndex *arg1 = (YoYInflationIndex *) 0 ;
  ext::shared_ptr< YoYInflationIndex const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationIndex > *)jarg1;
  arg1 = (YoYInflationIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((YoYInflationIndex const *)arg1)->ratio();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationIndex_underlyingIndex(void * jarg1) {
  void * jresult ;
  YoYInflationIndex *arg1 = (YoYInflationIndex *) 0 ;
  ext::shared_ptr< YoYInflationIndex const > *smartarg1 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationIndex > *)jarg1;
  arg1 = (YoYInflationIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((YoYInflationIndex const *)arg1)->underlyingIndex();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< ZeroInflationIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationIndex_yoyInflationTermStructure(void * jarg1) {
  void * jresult ;
  YoYInflationIndex *arg1 = (YoYInflationIndex *) 0 ;
  ext::shared_ptr< YoYInflationIndex const > *smartarg1 = 0 ;
  Handle< YoYInflationTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationIndex > *)jarg1;
  arg1 = (YoYInflationIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((YoYInflationIndex const *)arg1)->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 = new Handle< YoYInflationTermStructure >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationIndex_clone(void * jarg1, void * jarg2) {
  void * jresult ;
  YoYInflationIndex *arg1 = (YoYInflationIndex *) 0 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  ext::shared_ptr< YoYInflationIndex const > *smartarg1 = 0 ;
  ext::shared_ptr< YoYInflationIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationIndex > *)jarg1;
  arg1 = (YoYInflationIndex *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((YoYInflationIndex const *)arg1)->clone((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 = result ? new ext::shared_ptr< YoYInflationIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationIndex(void * jarg1) {
  YoYInflationIndex *arg1 = (YoYInflationIndex *) 0 ;
  ext::shared_ptr< YoYInflationIndex > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YoYInflationIndex > *)jarg1;
  arg1 = (YoYInflationIndex *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = 0 ;
  EUHICP *result = 0 ;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EUHICP *)new EUHICP((Handle< 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 = result ? new ext::shared_ptr<  EUHICP >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EUHICP__SWIG_2(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  EUHICP *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< ZeroInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EUHICP *)new EUHICP(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 = result ? new ext::shared_ptr<  EUHICP >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EUHICP__SWIG_3(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  EUHICP *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (EUHICP *)new EUHICP(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  EUHICP >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EUHICP(void * jarg1) {
  EUHICP *arg1 = (EUHICP *) 0 ;
  ext::shared_ptr< EUHICP > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EUHICP > *)jarg1;
  arg1 = (EUHICP *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = 0 ;
  EUHICPXT *result = 0 ;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EUHICPXT *)new EUHICPXT((Handle< 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 = result ? new ext::shared_ptr<  EUHICPXT >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EUHICPXT__SWIG_2(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  EUHICPXT *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< ZeroInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EUHICPXT *)new EUHICPXT(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 = result ? new ext::shared_ptr<  EUHICPXT >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EUHICPXT__SWIG_3(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  EUHICPXT *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (EUHICPXT *)new EUHICPXT(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  EUHICPXT >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_EUHICPXT(void * jarg1) {
  EUHICPXT *arg1 = (EUHICPXT *) 0 ;
  ext::shared_ptr< EUHICPXT > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  EUHICPXT > *)jarg1;
  arg1 = (EUHICPXT *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = 0 ;
  FRHICP *result = 0 ;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FRHICP *)new FRHICP((Handle< 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 = result ? new ext::shared_ptr<  FRHICP >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FRHICP__SWIG_2(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  FRHICP *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< ZeroInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FRHICP *)new FRHICP(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 = result ? new ext::shared_ptr<  FRHICP >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FRHICP__SWIG_3(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  FRHICP *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (FRHICP *)new FRHICP(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FRHICP >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FRHICP(void * jarg1) {
  FRHICP *arg1 = (FRHICP *) 0 ;
  ext::shared_ptr< FRHICP > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FRHICP > *)jarg1;
  arg1 = (FRHICP *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = 0 ;
  UKRPI *result = 0 ;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (UKRPI *)new UKRPI((Handle< 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 = result ? new ext::shared_ptr<  UKRPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UKRPI__SWIG_2(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  UKRPI *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< ZeroInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (UKRPI *)new UKRPI(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 = result ? new ext::shared_ptr<  UKRPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UKRPI__SWIG_3(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  UKRPI *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (UKRPI *)new UKRPI(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  UKRPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UKRPI(void * jarg1) {
  UKRPI *arg1 = (UKRPI *) 0 ;
  ext::shared_ptr< UKRPI > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  UKRPI > *)jarg1;
  arg1 = (UKRPI *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = 0 ;
  USCPI *result = 0 ;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (USCPI *)new USCPI((Handle< 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 = result ? new ext::shared_ptr<  USCPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_USCPI__SWIG_2(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  USCPI *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< ZeroInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (USCPI *)new USCPI(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 = result ? new ext::shared_ptr<  USCPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_USCPI__SWIG_3(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  USCPI *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (USCPI *)new USCPI(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  USCPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_USCPI(void * jarg1) {
  USCPI *arg1 = (USCPI *) 0 ;
  ext::shared_ptr< USCPI > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  USCPI > *)jarg1;
  arg1 = (USCPI *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = 0 ;
  ZACPI *result = 0 ;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZACPI *)new ZACPI((Handle< 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 = result ? new ext::shared_ptr<  ZACPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZACPI__SWIG_2(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  ZACPI *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< ZeroInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZACPI *)new ZACPI(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 = result ? new ext::shared_ptr<  ZACPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZACPI__SWIG_3(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  ZACPI *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (ZACPI *)new ZACPI(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  ZACPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZACPI(void * jarg1) {
  ZACPI *arg1 = (ZACPI *) 0 ;
  ext::shared_ptr< ZACPI > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZACPI > *)jarg1;
  arg1 = (ZACPI *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UKHICP__SWIG_0(void * jarg1) {
  void * jresult ;
  Handle< ZeroInflationTermStructure > *arg1 = 0 ;
  UKHICP *result = 0 ;
  
  arg1 = (Handle< ZeroInflationTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (UKHICP *)new UKHICP((Handle< 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 = result ? new ext::shared_ptr<  UKHICP >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UKHICP(void * jarg1) {
  UKHICP *arg1 = (UKHICP *) 0 ;
  ext::shared_ptr< UKHICP > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  UKHICP > *)jarg1;
  arg1 = (UKHICP *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  YYEUHICP *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYEUHICP *)new YYEUHICP(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 = result ? new ext::shared_ptr<  YYEUHICP >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYEUHICP__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYEUHICP *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYEUHICP *)new YYEUHICP(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  YYEUHICP >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYEUHICP(void * jarg1) {
  YYEUHICP *arg1 = (YYEUHICP *) 0 ;
  ext::shared_ptr< YYEUHICP > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YYEUHICP > *)jarg1;
  arg1 = (YYEUHICP *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  YYEUHICPXT *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYEUHICPXT *)new YYEUHICPXT(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 = result ? new ext::shared_ptr<  YYEUHICPXT >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYEUHICPXT__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYEUHICPXT *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYEUHICPXT *)new YYEUHICPXT(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  YYEUHICPXT >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYEUHICPXT(void * jarg1) {
  YYEUHICPXT *arg1 = (YYEUHICPXT *) 0 ;
  ext::shared_ptr< YYEUHICPXT > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YYEUHICPXT > *)jarg1;
  arg1 = (YYEUHICPXT *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYEUHICPr__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  YYEUHICPr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYEUHICPr *)new YYEUHICPr(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 = result ? new ext::shared_ptr<  YYEUHICPr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYEUHICPr__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYEUHICPr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYEUHICPr *)new YYEUHICPr(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  YYEUHICPr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYEUHICPr(void * jarg1) {
  YYEUHICPr *arg1 = (YYEUHICPr *) 0 ;
  ext::shared_ptr< YYEUHICPr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YYEUHICPr > *)jarg1;
  arg1 = (YYEUHICPr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  YYFRHICP *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYFRHICP *)new YYFRHICP(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 = result ? new ext::shared_ptr<  YYFRHICP >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYFRHICP__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYFRHICP *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYFRHICP *)new YYFRHICP(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  YYFRHICP >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYFRHICP(void * jarg1) {
  YYFRHICP *arg1 = (YYFRHICP *) 0 ;
  ext::shared_ptr< YYFRHICP > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YYFRHICP > *)jarg1;
  arg1 = (YYFRHICP *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYFRHICPr__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  YYFRHICPr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYFRHICPr *)new YYFRHICPr(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 = result ? new ext::shared_ptr<  YYFRHICPr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYFRHICPr__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYFRHICPr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYFRHICPr *)new YYFRHICPr(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  YYFRHICPr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYFRHICPr(void * jarg1) {
  YYFRHICPr *arg1 = (YYFRHICPr *) 0 ;
  ext::shared_ptr< YYFRHICPr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YYFRHICPr > *)jarg1;
  arg1 = (YYFRHICPr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  YYUKRPI *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYUKRPI *)new YYUKRPI(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 = result ? new ext::shared_ptr<  YYUKRPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYUKRPI__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYUKRPI *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYUKRPI *)new YYUKRPI(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  YYUKRPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYUKRPI(void * jarg1) {
  YYUKRPI *arg1 = (YYUKRPI *) 0 ;
  ext::shared_ptr< YYUKRPI > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YYUKRPI > *)jarg1;
  arg1 = (YYUKRPI *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYUKRPIr__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  YYUKRPIr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYUKRPIr *)new YYUKRPIr(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 = result ? new ext::shared_ptr<  YYUKRPIr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYUKRPIr__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYUKRPIr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYUKRPIr *)new YYUKRPIr(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  YYUKRPIr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYUKRPIr(void * jarg1) {
  YYUKRPIr *arg1 = (YYUKRPIr *) 0 ;
  ext::shared_ptr< YYUKRPIr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YYUKRPIr > *)jarg1;
  arg1 = (YYUKRPIr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  YYUSCPI *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYUSCPI *)new YYUSCPI(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 = result ? new ext::shared_ptr<  YYUSCPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYUSCPI__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYUSCPI *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYUSCPI *)new YYUSCPI(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  YYUSCPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYUSCPI(void * jarg1) {
  YYUSCPI *arg1 = (YYUSCPI *) 0 ;
  ext::shared_ptr< YYUSCPI > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YYUSCPI > *)jarg1;
  arg1 = (YYUSCPI *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYUSCPIr__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  YYUSCPIr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYUSCPIr *)new YYUSCPIr(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 = result ? new ext::shared_ptr<  YYUSCPIr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYUSCPIr__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYUSCPIr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYUSCPIr *)new YYUSCPIr(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  YYUSCPIr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYUSCPIr(void * jarg1) {
  YYUSCPIr *arg1 = (YYUSCPIr *) 0 ;
  ext::shared_ptr< YYUSCPIr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YYUSCPIr > *)jarg1;
  arg1 = (YYUSCPIr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  YYZACPI *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYZACPI *)new YYZACPI(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 = result ? new ext::shared_ptr<  YYZACPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYZACPI__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYZACPI *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYZACPI *)new YYZACPI(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  YYZACPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYZACPI(void * jarg1) {
  YYZACPI *arg1 = (YYZACPI *) 0 ;
  ext::shared_ptr< YYZACPI > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YYZACPI > *)jarg1;
  arg1 = (YYZACPI *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYZACPIr__SWIG_0(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  YYZACPIr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Handle< YoYInflationTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YYZACPIr *)new YYZACPIr(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 = result ? new ext::shared_ptr<  YYZACPIr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YYZACPIr__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  YYZACPIr *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  {
    try {
      result = (YYZACPIr *)new YYZACPIr(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  YYZACPIr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YYZACPIr(void * jarg1) {
  YYZACPIr *arg1 = (YYZACPIr *) 0 ;
  ext::shared_ptr< YYZACPIr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YYZACPIr > *)jarg1;
  arg1 = (YYZACPIr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AUCPI__SWIG_0(int jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  Frequency arg1 ;
  bool arg2 ;
  Handle< ZeroInflationTermStructure > *arg3 = 0 ;
  AUCPI *result = 0 ;
  
  arg1 = (Frequency)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (Handle< ZeroInflationTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AUCPI *)new AUCPI(arg1,arg2,(Handle< ZeroInflationTermStructure > 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 ? new ext::shared_ptr<  AUCPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AUCPI__SWIG_1(int jarg1, unsigned int jarg2) {
  void * jresult ;
  Frequency arg1 ;
  bool arg2 ;
  AUCPI *result = 0 ;
  
  arg1 = (Frequency)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (AUCPI *)new AUCPI(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 ? new ext::shared_ptr<  AUCPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AUCPI__SWIG_2(int jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
  void * jresult ;
  Frequency arg1 ;
  bool arg2 ;
  bool arg3 ;
  Handle< ZeroInflationTermStructure > *arg4 = 0 ;
  AUCPI *result = 0 ;
  
  arg1 = (Frequency)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Handle< ZeroInflationTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ZeroInflationTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AUCPI *)new AUCPI(arg1,arg2,arg3,(Handle< ZeroInflationTermStructure > 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 ? new ext::shared_ptr<  AUCPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AUCPI__SWIG_3(int jarg1, unsigned int jarg2, unsigned int jarg3) {
  void * jresult ;
  Frequency arg1 ;
  bool arg2 ;
  bool arg3 ;
  AUCPI *result = 0 ;
  
  arg1 = (Frequency)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (AUCPI *)new AUCPI(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 ? new ext::shared_ptr<  AUCPI >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AUCPI(void * jarg1) {
  AUCPI *arg1 = (AUCPI *) 0 ;
  ext::shared_ptr< AUCPI > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AUCPI > *)jarg1;
  arg1 = (AUCPI *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_CPI_laggedFixing(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  double jresult ;
  ext::shared_ptr< ZeroInflationIndex > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  CPI::InterpolationType arg4 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull1 ;
  Real result;
  
  arg1 = jarg1 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg1 : &tempnull1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (CPI::InterpolationType)jarg4; 
  {
    try {
      result = (Real)CPI::laggedFixing((ext::shared_ptr< ZeroInflationIndex > const &)*arg1,(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 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_InflationCoupon_fixingDate(void * jarg1) {
  void * jresult ;
  InflationCoupon *arg1 = (InflationCoupon *) 0 ;
  ext::shared_ptr< InflationCoupon const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationCoupon > *)jarg1;
  arg1 = (InflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InflationCoupon const *)arg1)->fixingDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_InflationCoupon_fixingDays(void * jarg1) {
  int jresult ;
  InflationCoupon *arg1 = (InflationCoupon *) 0 ;
  ext::shared_ptr< InflationCoupon const > *smartarg1 = 0 ;
  Integer result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationCoupon > *)jarg1;
  arg1 = (InflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Integer)((InflationCoupon const *)arg1)->fixingDays();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InflationCoupon_observationLag(void * jarg1) {
  void * jresult ;
  InflationCoupon *arg1 = (InflationCoupon *) 0 ;
  ext::shared_ptr< InflationCoupon const > *smartarg1 = 0 ;
  Period result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationCoupon > *)jarg1;
  arg1 = (InflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InflationCoupon const *)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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_InflationCoupon_indexFixing(void * jarg1) {
  double jresult ;
  InflationCoupon *arg1 = (InflationCoupon *) 0 ;
  ext::shared_ptr< InflationCoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationCoupon > *)jarg1;
  arg1 = (InflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((InflationCoupon const *)arg1)->indexFixing();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InflationCoupon_index(void * jarg1) {
  void * jresult ;
  InflationCoupon *arg1 = (InflationCoupon *) 0 ;
  ext::shared_ptr< InflationCoupon const > *smartarg1 = 0 ;
  ext::shared_ptr< InflationIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const InflationCoupon > *)jarg1;
  arg1 = (InflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InflationCoupon const *)arg1)->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 = result ? new ext::shared_ptr< InflationIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InflationCoupon(void * jarg1) {
  InflationCoupon *arg1 = (InflationCoupon *) 0 ;
  ext::shared_ptr< InflationCoupon > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InflationCoupon > *)jarg1;
  arg1 = (InflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_inflation_coupon(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  ext::shared_ptr< CashFlow > tempnull1 ;
  ext::shared_ptr< InflationCoupon > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< CashFlow > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_inflation_coupon((ext::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 = result ? new ext::shared_ptr< InflationCoupon >(result) : 0; 
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CPICouponPricer(void * jarg1) {
  CPICouponPricer *arg1 = (CPICouponPricer *) 0 ;
  ext::shared_ptr< CPICouponPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CPICouponPricer > *)jarg1;
  arg1 = (CPICouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_0(double jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, double jarg10, void * jarg11, void * jarg12, void * jarg13) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,(Date const &)*arg11,(Date const &)*arg12,(Date 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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_1(double jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, double jarg10, void * jarg11, void * jarg12) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_2(double jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, double jarg10, void * jarg11) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_3(double jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, double jarg10) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_4(void * jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, double jarg10, void * jarg11, void * jarg12, void * jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon((Date const &)*arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,(Date const &)*arg11,(Date const &)*arg12,(Date 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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_5(void * jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, double jarg10, void * jarg11, void * jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon((Date const &)*arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_6(void * jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, double jarg10, void * jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon((Date const &)*arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_7(void * jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, double jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (CPICoupon *)new CPICoupon((Date const &)*arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_8(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, void * jarg10, double jarg11, void * jarg12, void * jarg13, void * jarg14) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  CPI::InterpolationType arg9 ;
  DayCounter *arg10 = 0 ;
  Real arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  Date *arg14 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull7 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg7 : &tempnull7; 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg9 = (CPI::InterpolationType)jarg9; 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (Real)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (Date *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,arg11,(Date const &)*arg12,(Date const &)*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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_9(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, void * jarg10, double jarg11, void * jarg12, void * jarg13) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  CPI::InterpolationType arg9 ;
  DayCounter *arg10 = 0 ;
  Real arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull7 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg7 : &tempnull7; 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg9 = (CPI::InterpolationType)jarg9; 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (Real)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,arg11,(Date const &)*arg12,(Date 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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_10(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, void * jarg10, double jarg11, void * jarg12) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  CPI::InterpolationType arg9 ;
  DayCounter *arg10 = 0 ;
  Real arg11 ;
  Date *arg12 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull7 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg7 : &tempnull7; 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg9 = (CPI::InterpolationType)jarg9; 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (Real)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,(Period const &)*arg8,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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_11(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, void * jarg10, double jarg11) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  CPI::InterpolationType arg9 ;
  DayCounter *arg10 = 0 ;
  Real arg11 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull7 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg7 : &tempnull7; 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg9 = (CPI::InterpolationType)jarg9; 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,(Period const &)*arg8,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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_12(double jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, double jarg10, double jarg11, void * jarg12, void * jarg13, void * jarg14) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Spread arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  Date *arg14 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Spread)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (Date *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,arg11,(Date const &)*arg12,(Date const &)*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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_13(double jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, double jarg10, double jarg11, void * jarg12, void * jarg13) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Spread arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Spread)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,arg11,(Date const &)*arg12,(Date 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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_14(double jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, double jarg10, double jarg11, void * jarg12) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Spread arg11 ;
  Date *arg12 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Spread)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_15(double jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, double jarg10, double jarg11) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Spread arg11 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Spread)jarg11; 
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_16(void * jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, double jarg10, double jarg11, void * jarg12, void * jarg13, void * jarg14) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Spread arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  Date *arg14 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Spread)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (Date *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon((Date const &)*arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,arg11,(Date const &)*arg12,(Date const &)*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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_17(void * jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, double jarg10, double jarg11, void * jarg12, void * jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Spread arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Spread)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon((Date const &)*arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,arg11,(Date const &)*arg12,(Date 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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_18(void * jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, double jarg10, double jarg11, void * jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Spread arg11 ;
  Date *arg12 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Spread)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon((Date const &)*arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_19(void * jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, double jarg10, double jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Spread arg11 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Spread)jarg11; 
  {
    try {
      result = (CPICoupon *)new CPICoupon((Date const &)*arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_20(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, void * jarg10, double jarg11, double jarg12, void * jarg13, void * jarg14, void * jarg15) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  CPI::InterpolationType arg9 ;
  DayCounter *arg10 = 0 ;
  Real arg11 ;
  Spread arg12 ;
  Date *arg13 = 0 ;
  Date *arg14 = 0 ;
  Date *arg15 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull7 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg7 : &tempnull7; 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg9 = (CPI::InterpolationType)jarg9; 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (Real)jarg11; 
  arg12 = (Spread)jarg12; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (Date *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg15 = (Date *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,arg11,arg12,(Date const &)*arg13,(Date const &)*arg14,(Date 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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_21(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, void * jarg10, double jarg11, double jarg12, void * jarg13, void * jarg14) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  CPI::InterpolationType arg9 ;
  DayCounter *arg10 = 0 ;
  Real arg11 ;
  Spread arg12 ;
  Date *arg13 = 0 ;
  Date *arg14 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull7 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg7 : &tempnull7; 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg9 = (CPI::InterpolationType)jarg9; 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (Real)jarg11; 
  arg12 = (Spread)jarg12; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (Date *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,arg11,arg12,(Date const &)*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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_22(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, void * jarg10, double jarg11, double jarg12, void * jarg13) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  CPI::InterpolationType arg9 ;
  DayCounter *arg10 = 0 ;
  Real arg11 ;
  Spread arg12 ;
  Date *arg13 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull7 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg7 : &tempnull7; 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg9 = (CPI::InterpolationType)jarg9; 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (Real)jarg11; 
  arg12 = (Spread)jarg12; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,arg11,arg12,(Date 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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICoupon__SWIG_23(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, void * jarg10, double jarg11, double jarg12) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  CPI::InterpolationType arg9 ;
  DayCounter *arg10 = 0 ;
  Real arg11 ;
  Spread arg12 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull7 ;
  CPICoupon *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg7 : &tempnull7; 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg9 = (CPI::InterpolationType)jarg9; 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (Real)jarg11; 
  arg12 = (Spread)jarg12; 
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,(Period const &)*arg8,arg9,(DayCounter 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 = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CPICoupon_fixedRate(void * jarg1) {
  double jresult ;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CPICoupon > *)jarg1;
  arg1 = (CPICoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CPICoupon const *)arg1)->fixedRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CPICoupon_spread(void * jarg1) {
  double jresult ;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  Spread result;
  
  
  smartarg1 = (ext::shared_ptr< const CPICoupon > *)jarg1;
  arg1 = (CPICoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Spread)((CPICoupon const *)arg1)->spread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CPICoupon_adjustedIndexGrowth(void * jarg1) {
  double jresult ;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CPICoupon > *)jarg1;
  arg1 = (CPICoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CPICoupon const *)arg1)->adjustedIndexGrowth();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CPICoupon_indexFixing(void * jarg1) {
  double jresult ;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CPICoupon > *)jarg1;
  arg1 = (CPICoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CPICoupon const *)arg1)->indexFixing();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CPICoupon_indexRatio(void * jarg1, void * jarg2) {
  double jresult ;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  Date arg2 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  Date *argp2 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const CPICoupon > *)jarg1;
  arg1 = (CPICoupon *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (Real)((CPICoupon const *)arg1)->indexRatio(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CPICoupon_baseCPI(void * jarg1) {
  double jresult ;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CPICoupon > *)jarg1;
  arg1 = (CPICoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CPICoupon const *)arg1)->baseCPI();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPICoupon_baseDate(void * jarg1) {
  void * jresult ;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const CPICoupon > *)jarg1;
  arg1 = (CPICoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((CPICoupon const *)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(result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_CPICoupon_observationInterpolation(void * jarg1) {
  int jresult ;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  CPI::InterpolationType result;
  
  
  smartarg1 = (ext::shared_ptr< const CPICoupon > *)jarg1;
  arg1 = (CPICoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (CPI::InterpolationType)((CPICoupon const *)arg1)->observationInterpolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_CPICoupon_cpiIndex(void * jarg1) {
  void * jresult ;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const CPICoupon > *)jarg1;
  arg1 = (CPICoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((CPICoupon const *)arg1)->cpiIndex();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< ZeroInflationIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CPICoupon_setPricer(void * jarg1, void * jarg2) {
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  ext::shared_ptr< CPICouponPricer > *arg2 = 0 ;
  ext::shared_ptr< CPICoupon > *smartarg1 = 0 ;
  ext::shared_ptr< CPICouponPricer > tempnull2 ;
  
  
  smartarg1 = (ext::shared_ptr<  CPICoupon > *)jarg1;
  arg1 = (CPICoupon *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (ext::shared_ptr< CPICouponPricer > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->setPricer((ext::shared_ptr< CPICouponPricer > 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_CPICoupon(void * jarg1) {
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  ext::shared_ptr< CPICoupon > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CPICoupon > *)jarg1;
  arg1 = (CPICoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_cpi_coupon(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  ext::shared_ptr< CashFlow > tempnull1 ;
  ext::shared_ptr< CPICoupon > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< CashFlow > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_cpi_coupon((ext::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 = result ? new ext::shared_ptr< CPICoupon >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICashFlow__SWIG_0(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, unsigned int jarg9) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< ZeroInflationIndex > *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Date *arg8 = 0 ;
  bool arg9 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull2 ;
  CPICashFlow *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg2 : &tempnull2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Period *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg9 = jarg9 ? true : false; 
  {
    try {
      result = (CPICashFlow *)new CPICashFlow(arg1,(ext::shared_ptr< ZeroInflationIndex > const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Period const &)*arg6,arg7,(Date 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 = result ? new ext::shared_ptr<  CPICashFlow >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPICashFlow__SWIG_1(double jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< ZeroInflationIndex > *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Date *arg8 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull2 ;
  CPICashFlow *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg2 : &tempnull2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Period *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPICashFlow *)new CPICashFlow(arg1,(ext::shared_ptr< ZeroInflationIndex > const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Period const &)*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 ? new ext::shared_ptr<  CPICashFlow >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_CPICashFlow_interpolation(void * jarg1) {
  int jresult ;
  CPICashFlow *arg1 = (CPICashFlow *) 0 ;
  ext::shared_ptr< CPICashFlow const > *smartarg1 = 0 ;
  CPI::InterpolationType result;
  
  
  smartarg1 = (ext::shared_ptr< const CPICashFlow > *)jarg1;
  arg1 = (CPICashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (CPI::InterpolationType)((CPICashFlow const *)arg1)->interpolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_CPICashFlow_frequency(void * jarg1) {
  int jresult ;
  CPICashFlow *arg1 = (CPICashFlow *) 0 ;
  ext::shared_ptr< CPICashFlow const > *smartarg1 = 0 ;
  Frequency result;
  
  
  smartarg1 = (ext::shared_ptr< const CPICashFlow > *)jarg1;
  arg1 = (CPICashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Frequency)((CPICashFlow 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_delete_CPICashFlow(void * jarg1) {
  CPICashFlow *arg1 = (CPICashFlow *) 0 ;
  ext::shared_ptr< CPICashFlow > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CPICashFlow > *)jarg1;
  arg1 = (CPICashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_cpi_cashflow(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  ext::shared_ptr< CashFlow > tempnull1 ;
  ext::shared_ptr< CPICashFlow > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< CashFlow > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_cpi_cashflow((ext::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 = result ? new ext::shared_ptr< CPICashFlow >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPILeg__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13, int jarg14, unsigned int jarg15, void * jarg16, unsigned int jarg17, int jarg18) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg3 = 0 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  bool arg15 ;
  Calendar *arg16 = 0 ;
  bool arg17 ;
  CPI::InterpolationType arg18 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  arg15 = jarg15 ? true : false; 
  arg16 = (Calendar *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg17 = jarg17 ? true : false; 
  arg18 = (CPI::InterpolationType)jarg18; 
  {
    try {
      result = _CPILeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< ZeroInflationIndex > const &)*arg3,arg4,(Period const &)*arg5,(DayCounter const &)*arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,(Period const &)*arg12,(Calendar const &)*arg13,arg14,arg15,(Calendar const &)*arg16,arg17,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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPILeg__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13, int jarg14, unsigned int jarg15, void * jarg16, unsigned int jarg17) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg3 = 0 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  bool arg15 ;
  Calendar *arg16 = 0 ;
  bool arg17 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  arg15 = jarg15 ? true : false; 
  arg16 = (Calendar *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = _CPILeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< ZeroInflationIndex > const &)*arg3,arg4,(Period const &)*arg5,(DayCounter const &)*arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,(Period const &)*arg12,(Calendar const &)*arg13,arg14,arg15,(Calendar const &)*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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPILeg__SWIG_2(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13, int jarg14, unsigned int jarg15, void * jarg16) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg3 = 0 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  bool arg15 ;
  Calendar *arg16 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  arg15 = jarg15 ? true : false; 
  arg16 = (Calendar *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CPILeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< ZeroInflationIndex > const &)*arg3,arg4,(Period const &)*arg5,(DayCounter const &)*arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,(Period const &)*arg12,(Calendar const &)*arg13,arg14,arg15,(Calendar 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPILeg__SWIG_3(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13, int jarg14, unsigned int jarg15) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg3 = 0 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  bool arg15 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = _CPILeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< ZeroInflationIndex > const &)*arg3,arg4,(Period const &)*arg5,(DayCounter const &)*arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,(Period const &)*arg12,(Calendar const &)*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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPILeg__SWIG_4(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13, int jarg14) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg3 = 0 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  {
    try {
      result = _CPILeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< ZeroInflationIndex > const &)*arg3,arg4,(Period const &)*arg5,(DayCounter const &)*arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,(Period const &)*arg12,(Calendar 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPILeg__SWIG_5(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg3 = 0 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CPILeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< ZeroInflationIndex > const &)*arg3,arg4,(Period const &)*arg5,(DayCounter const &)*arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,(Period 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPILeg__SWIG_6(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg3 = 0 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  Period *arg12 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CPILeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< ZeroInflationIndex > const &)*arg3,arg4,(Period const &)*arg5,(DayCounter const &)*arg6,arg7,(std::vector< double > const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*arg11,(Period 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPILeg__SWIG_7(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg3 = 0 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CPILeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< ZeroInflationIndex > const &)*arg3,arg4,(Period const &)*arg5,(DayCounter const &)*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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPILeg__SWIG_8(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg3 = 0 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CPILeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< ZeroInflationIndex > const &)*arg3,arg4,(Period const &)*arg5,(DayCounter const &)*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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPILeg__SWIG_9(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg3 = 0 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CPILeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< ZeroInflationIndex > const &)*arg3,arg4,(Period const &)*arg5,(DayCounter const &)*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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPILeg__SWIG_10(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, void * jarg8) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg3 = 0 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  std::vector< Real > *arg8 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (std::vector< Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CPILeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< ZeroInflationIndex > const &)*arg3,arg4,(Period const &)*arg5,(DayCounter const &)*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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPILeg__SWIG_11(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg3 = 0 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  {
    try {
      result = _CPILeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< ZeroInflationIndex > const &)*arg3,arg4,(Period 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPILeg__SWIG_12(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg3 = 0 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CPILeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< ZeroInflationIndex > const &)*arg3,arg4,(Period 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPILeg__SWIG_13(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  std::vector< Real > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg3 = 0 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (std::vector< Real > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg2 = (Schedule *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _CPILeg((std::vector< double > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< ZeroInflationIndex > const &)*arg3,arg4,(Period 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 Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroInflationCashFlow__SWIG_0(double jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, unsigned int jarg8) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< ZeroInflationIndex > *arg2 = 0 ;
  CPI::InterpolationType arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  Date *arg7 = 0 ;
  bool arg8 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull2 ;
  ZeroInflationCashFlow *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg2 : &tempnull2; 
  arg3 = (CPI::InterpolationType)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Period *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (ZeroInflationCashFlow *)new ZeroInflationCashFlow(arg1,(ext::shared_ptr< ZeroInflationIndex > const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*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 ? new ext::shared_ptr<  ZeroInflationCashFlow >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroInflationCashFlow__SWIG_1(double jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< ZeroInflationIndex > *arg2 = 0 ;
  CPI::InterpolationType arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  Date *arg7 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull2 ;
  ZeroInflationCashFlow *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg2 : &tempnull2; 
  arg3 = (CPI::InterpolationType)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Period *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroInflationCashFlow *)new ZeroInflationCashFlow(arg1,(ext::shared_ptr< ZeroInflationIndex > const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period 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 = result ? new ext::shared_ptr<  ZeroInflationCashFlow >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroInflationCashFlow_notional(void * jarg1) {
  double jresult ;
  ZeroInflationCashFlow *arg1 = (ZeroInflationCashFlow *) 0 ;
  ext::shared_ptr< ZeroInflationCashFlow const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroInflationCashFlow > *)jarg1;
  arg1 = (ZeroInflationCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ZeroInflationCashFlow const *)arg1)->notional();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationCashFlow_baseDate(void * jarg1) {
  void * jresult ;
  ZeroInflationCashFlow *arg1 = (ZeroInflationCashFlow *) 0 ;
  ext::shared_ptr< ZeroInflationCashFlow const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroInflationCashFlow > *)jarg1;
  arg1 = (ZeroInflationCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((ZeroInflationCashFlow const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationCashFlow_fixingDate(void * jarg1) {
  void * jresult ;
  ZeroInflationCashFlow *arg1 = (ZeroInflationCashFlow *) 0 ;
  ext::shared_ptr< ZeroInflationCashFlow const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroInflationCashFlow > *)jarg1;
  arg1 = (ZeroInflationCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((ZeroInflationCashFlow const *)arg1)->fixingDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ZeroInflationCashFlow_growthOnly(void * jarg1) {
  unsigned int jresult ;
  ZeroInflationCashFlow *arg1 = (ZeroInflationCashFlow *) 0 ;
  ext::shared_ptr< ZeroInflationCashFlow const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroInflationCashFlow > *)jarg1;
  arg1 = (ZeroInflationCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((ZeroInflationCashFlow const *)arg1)->growthOnly();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_ZeroInflationCashFlow_observationInterpolation(void * jarg1) {
  int jresult ;
  ZeroInflationCashFlow *arg1 = (ZeroInflationCashFlow *) 0 ;
  ext::shared_ptr< ZeroInflationCashFlow const > *smartarg1 = 0 ;
  CPI::InterpolationType result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroInflationCashFlow > *)jarg1;
  arg1 = (ZeroInflationCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (CPI::InterpolationType)((ZeroInflationCashFlow const *)arg1)->observationInterpolation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_ZeroInflationCashFlow_zeroInflationIndex(void * jarg1) {
  void * jresult ;
  ZeroInflationCashFlow *arg1 = (ZeroInflationCashFlow *) 0 ;
  ext::shared_ptr< ZeroInflationCashFlow const > *smartarg1 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const ZeroInflationCashFlow > *)jarg1;
  arg1 = (ZeroInflationCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((ZeroInflationCashFlow const *)arg1)->zeroInflationIndex();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< ZeroInflationIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroInflationCashFlow(void * jarg1) {
  ZeroInflationCashFlow *arg1 = (ZeroInflationCashFlow *) 0 ;
  ext::shared_ptr< ZeroInflationCashFlow > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZeroInflationCashFlow > *)jarg1;
  arg1 = (ZeroInflationCashFlow *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_zero_inflation_cash_flow(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  ext::shared_ptr< CashFlow > tempnull1 ;
  ext::shared_ptr< ZeroInflationCashFlow > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< CashFlow > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_zero_inflation_cash_flow((ext::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 = result ? new ext::shared_ptr< ZeroInflationCashFlow >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroHelper_quote(void * jarg1) {
  void * jresult ;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > *smartarg1 = 0 ;
  Handle< Quote > result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<ZeroInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< ZeroInflationTermStructure > const *)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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroHelper_latestDate(void * jarg1) {
  void * jresult ;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<ZeroInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< ZeroInflationTermStructure > const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroHelper_earliestDate(void * jarg1) {
  void * jresult ;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<ZeroInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< ZeroInflationTermStructure > const *)arg1)->earliestDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroHelper_maturityDate(void * jarg1) {
  void * jresult ;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<ZeroInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< ZeroInflationTermStructure > const *)arg1)->maturityDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroHelper_latestRelevantDate(void * jarg1) {
  void * jresult ;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<ZeroInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< ZeroInflationTermStructure > const *)arg1)->latestRelevantDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroHelper_pillarDate(void * jarg1) {
  void * jresult ;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<ZeroInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< ZeroInflationTermStructure > const *)arg1)->pillarDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroHelper_impliedQuote(void * jarg1) {
  double jresult ;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<ZeroInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((BootstrapHelper< ZeroInflationTermStructure > const *)arg1)->impliedQuote();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroHelper_quoteError(void * jarg1) {
  double jresult ;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<ZeroInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((BootstrapHelper< ZeroInflationTermStructure > const *)arg1)->quoteError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_ZeroHelper(void * jarg1) {
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BootstrapHelper<ZeroInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<ZeroInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_quote(void * jarg1) {
  void * jresult ;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > *smartarg1 = 0 ;
  Handle< Quote > result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<YoYInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< YoYInflationTermStructure > const *)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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYHelper_latestDate(void * jarg1) {
  void * jresult ;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<YoYInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< YoYInflationTermStructure > const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYHelper_earliestDate(void * jarg1) {
  void * jresult ;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<YoYInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< YoYInflationTermStructure > const *)arg1)->earliestDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYHelper_maturityDate(void * jarg1) {
  void * jresult ;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<YoYInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< YoYInflationTermStructure > const *)arg1)->maturityDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYHelper_latestRelevantDate(void * jarg1) {
  void * jresult ;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<YoYInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< YoYInflationTermStructure > const *)arg1)->latestRelevantDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYHelper_pillarDate(void * jarg1) {
  void * jresult ;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<YoYInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< YoYInflationTermStructure > const *)arg1)->pillarDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYHelper_impliedQuote(void * jarg1) {
  double jresult ;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<YoYInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((BootstrapHelper< YoYInflationTermStructure > const *)arg1)->impliedQuote();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYHelper_quoteError(void * jarg1) {
  double jresult ;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<YoYInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((BootstrapHelper< YoYInflationTermStructure > const *)arg1)->quoteError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_YoYHelper(void * jarg1) {
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BootstrapHelper<YoYInflationTermStructure> > *)jarg1;
  arg1 = (BootstrapHelper<YoYInflationTermStructure> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYOptionHelper_quote(void * jarg1) {
  void * jresult ;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > *smartarg1 = 0 ;
  Handle< Quote > result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > *)jarg1;
  arg1 = (BootstrapHelper<YoYOptionletVolatilitySurface> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< YoYOptionletVolatilitySurface > const *)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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYOptionHelper_latestDate(void * jarg1) {
  void * jresult ;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > *)jarg1;
  arg1 = (BootstrapHelper<YoYOptionletVolatilitySurface> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< YoYOptionletVolatilitySurface > const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYOptionHelper_earliestDate(void * jarg1) {
  void * jresult ;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > *)jarg1;
  arg1 = (BootstrapHelper<YoYOptionletVolatilitySurface> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< YoYOptionletVolatilitySurface > const *)arg1)->earliestDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYOptionHelper_maturityDate(void * jarg1) {
  void * jresult ;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > *)jarg1;
  arg1 = (BootstrapHelper<YoYOptionletVolatilitySurface> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< YoYOptionletVolatilitySurface > const *)arg1)->maturityDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYOptionHelper_latestRelevantDate(void * jarg1) {
  void * jresult ;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > *)jarg1;
  arg1 = (BootstrapHelper<YoYOptionletVolatilitySurface> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< YoYOptionletVolatilitySurface > const *)arg1)->latestRelevantDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYOptionHelper_pillarDate(void * jarg1) {
  void * jresult ;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > *)jarg1;
  arg1 = (BootstrapHelper<YoYOptionletVolatilitySurface> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BootstrapHelper< YoYOptionletVolatilitySurface > const *)arg1)->pillarDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionHelper_impliedQuote(void * jarg1) {
  double jresult ;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > *)jarg1;
  arg1 = (BootstrapHelper<YoYOptionletVolatilitySurface> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((BootstrapHelper< YoYOptionletVolatilitySurface > const *)arg1)->impliedQuote();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYOptionHelper_quoteError(void * jarg1) {
  double jresult ;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > *)jarg1;
  arg1 = (BootstrapHelper<YoYOptionletVolatilitySurface> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((BootstrapHelper< YoYOptionletVolatilitySurface > const *)arg1)->quoteError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_YoYOptionHelper(void * jarg1) {
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BootstrapHelper<YoYOptionletVolatilitySurface> > *)jarg1;
  arg1 = (BootstrapHelper<YoYOptionletVolatilitySurface> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)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< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *arg2 = 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::shared_ptr< BootstrapHelper< 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 unsigned long SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > 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< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > 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< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::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< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< 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_new_ZeroHelperVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >((std::vector< ext::shared_ptr< BootstrapHelper< 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_ZeroHelperVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)new_std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_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_ZeroHelperVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_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 = result ? new ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_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 = *result ? new std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *arg3 = 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__setitem(arg1,arg2,(ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > 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< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__AddRange(arg1,(std::vector< ext::shared_ptr< BootstrapHelper< 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_ZeroHelperVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_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_ZeroHelperVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *arg3 = 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__Insert(arg1,arg2,(ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > 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< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > 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< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_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_ZeroHelperVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_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_ZeroHelperVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > tempnull1 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__Repeat((ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > 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< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_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_ZeroHelperVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_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_ZeroHelperVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > 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< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *arg2 = 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__Contains(arg1,(ext::shared_ptr< BootstrapHelper< 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 = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *arg2 = 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__IndexOf(arg1,(ext::shared_ptr< BootstrapHelper< 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 = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *arg2 = 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__LastIndexOf(arg1,(ext::shared_ptr< BootstrapHelper< 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 = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_ZeroHelperVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *arg2 = 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__Remove(arg1,(ext::shared_ptr< BootstrapHelper< 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 = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroHelperVector(void * jarg1) {
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< 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 void SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_Clear(void * jarg1) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)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< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *arg2 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::shared_ptr< BootstrapHelper< 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 unsigned long SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > 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< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > 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< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::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< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< 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_new_YoYHelperVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >((std::vector< ext::shared_ptr< BootstrapHelper< 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_YoYHelperVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)new_std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_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_YoYHelperVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_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 = result ? new ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_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 = *result ? new std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *arg3 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__setitem(arg1,arg2,(ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > 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< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__AddRange(arg1,(std::vector< ext::shared_ptr< BootstrapHelper< 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_YoYHelperVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_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_YoYHelperVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *arg3 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__Insert(arg1,arg2,(ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > 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< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > 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< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_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_YoYHelperVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_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_YoYHelperVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > tempnull1 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__Repeat((ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > 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< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_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_YoYHelperVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_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_YoYHelperVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > 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< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *arg2 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__Contains(arg1,(ext::shared_ptr< BootstrapHelper< 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 = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *arg2 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__IndexOf(arg1,(ext::shared_ptr< BootstrapHelper< 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 = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *arg2 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__LastIndexOf(arg1,(ext::shared_ptr< BootstrapHelper< 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 = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_YoYHelperVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *arg2 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__Remove(arg1,(ext::shared_ptr< BootstrapHelper< 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 = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYHelperVector(void * jarg1) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< 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_YoYOptionHelperVector_Clear(void * jarg1) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)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_YoYOptionHelperVector_Add(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *arg2 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > 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_YoYOptionHelperVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > 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_YoYOptionHelperVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > 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_YoYOptionHelperVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::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_YoYOptionHelperVector__SWIG_0() {
  void * jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYOptionHelperVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)new_std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_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_YoYOptionHelperVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_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 = result ? new ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYOptionHelperVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_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 = *result ? new std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYOptionHelperVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *arg3 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__setitem(arg1,arg2,(ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > 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_YoYOptionHelperVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__AddRange(arg1,(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > 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_YoYOptionHelperVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_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_YoYOptionHelperVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *arg3 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__Insert(arg1,arg2,(ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > 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_YoYOptionHelperVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > 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_YoYOptionHelperVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_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_YoYOptionHelperVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_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_YoYOptionHelperVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > tempnull1 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__Repeat((ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > 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_YoYOptionHelperVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_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_YoYOptionHelperVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_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_YoYOptionHelperVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > 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_YoYOptionHelperVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *arg2 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__Contains(arg1,(ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_YoYOptionHelperVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *arg2 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__IndexOf(arg1,(ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_YoYOptionHelperVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *arg2 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__LastIndexOf(arg1,(ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_YoYOptionHelperVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *arg2 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__Remove(arg1,(ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_YoYOptionHelperVector(void * jarg1) {
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Date *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull7 ;
  ZeroCouponInflationSwapHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg7 : &tempnull7; 
  arg8 = (CPI::InterpolationType)jarg8; 
  arg9 = (Handle< YieldTermStructure > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroCouponInflationSwapHelper *)new ZeroCouponInflationSwapHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Date const &)*arg3,(Calendar const &)*arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > 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 ? new ext::shared_ptr<  ZeroCouponInflationSwapHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroCouponInflationSwapHelper(void * jarg1) {
  ZeroCouponInflationSwapHelper *arg1 = (ZeroCouponInflationSwapHelper *) 0 ;
  ext::shared_ptr< ZeroCouponInflationSwapHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZeroCouponInflationSwapHelper > *)jarg1;
  arg1 = (ZeroCouponInflationSwapHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Date *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull7 ;
  YearOnYearInflationSwapHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< YoYInflationIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YearOnYearInflationSwapHelper *)new YearOnYearInflationSwapHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Date const &)*arg3,(Calendar const &)*arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< YoYInflationIndex > 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 = result ? new ext::shared_ptr<  YearOnYearInflationSwapHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YearOnYearInflationSwapHelper(void * jarg1) {
  YearOnYearInflationSwapHelper *arg1 = (YearOnYearInflationSwapHelper *) 0 ;
  ext::shared_ptr< YearOnYearInflationSwapHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YearOnYearInflationSwapHelper > *)jarg1;
  arg1 = (YearOnYearInflationSwapHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, double jarg6, void * jarg7, double jarg8, void * jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  Rate arg6 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg7 = 0 ;
  Real arg8 ;
  Linear *arg9 = 0 ;
  PiecewiseZeroInflationCurve< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = (Rate)jarg6; 
  arg7 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const & is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  arg9 = (Linear *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseZeroInflationCurve< Linear > *)new PiecewiseZeroInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const &)*arg7,arg8,(Linear 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 ? new ext::shared_ptr<  PiecewiseZeroInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseZeroInflation__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, double jarg6, void * jarg7, double jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  Rate arg6 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg7 = 0 ;
  Real arg8 ;
  PiecewiseZeroInflationCurve< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = (Rate)jarg6; 
  arg7 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const & is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (PiecewiseZeroInflationCurve< Linear > *)new PiecewiseZeroInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > 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 ? new ext::shared_ptr<  PiecewiseZeroInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseZeroInflation__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, double jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  Rate arg6 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg7 = 0 ;
  PiecewiseZeroInflationCurve< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = (Rate)jarg6; 
  arg7 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseZeroInflationCurve< Linear > *)new PiecewiseZeroInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > 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 ? new ext::shared_ptr<  PiecewiseZeroInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseZeroInflation_dates(void * jarg1) {
  void * jresult ;
  PiecewiseZeroInflationCurve< Linear > *arg1 = (PiecewiseZeroInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseZeroInflationCurve<Linear> > *)jarg1;
  arg1 = (PiecewiseZeroInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseZeroInflationCurve< Linear > 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_PiecewiseZeroInflation_times(void * jarg1) {
  void * jresult ;
  PiecewiseZeroInflationCurve< Linear > *arg1 = (PiecewiseZeroInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseZeroInflationCurve<Linear> > *)jarg1;
  arg1 = (PiecewiseZeroInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseZeroInflationCurve< Linear > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseZeroInflation_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseZeroInflationCurve< Linear > *arg1 = (PiecewiseZeroInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseZeroInflationCurve<Linear> > *)jarg1;
  arg1 = (PiecewiseZeroInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseZeroInflationCurve< Linear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PiecewiseZeroInflation(void * jarg1) {
  PiecewiseZeroInflationCurve< Linear > *arg1 = (PiecewiseZeroInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseZeroInflationCurve<Linear> > *)jarg1;
  arg1 = (PiecewiseZeroInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, double jarg9, void * jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  bool arg6 ;
  Rate arg7 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg8 = 0 ;
  Real arg9 ;
  Linear *arg10 = 0 ;
  PiecewiseYoYInflationCurve< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (Rate)jarg7; 
  arg8 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Linear *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseYoYInflationCurve< Linear > *)new PiecewiseYoYInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,arg7,(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const &)*arg8,arg9,(Linear 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 = result ? new ext::shared_ptr<  PiecewiseYoYInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, double jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  bool arg6 ;
  Rate arg7 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg8 = 0 ;
  Real arg9 ;
  PiecewiseYoYInflationCurve< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (Rate)jarg7; 
  arg8 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (PiecewiseYoYInflationCurve< Linear > *)new PiecewiseYoYInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,arg7,(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > 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 = result ? new ext::shared_ptr<  PiecewiseYoYInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  bool arg6 ;
  Rate arg7 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg8 = 0 ;
  PiecewiseYoYInflationCurve< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (Rate)jarg7; 
  arg8 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseYoYInflationCurve< Linear > *)new PiecewiseYoYInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,arg7,(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > 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 ? new ext::shared_ptr<  PiecewiseYoYInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseYoYInflation_dates(void * jarg1) {
  void * jresult ;
  PiecewiseYoYInflationCurve< Linear > *arg1 = (PiecewiseYoYInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseYoYInflationCurve<Linear> > *)jarg1;
  arg1 = (PiecewiseYoYInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseYoYInflationCurve< Linear > 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_PiecewiseYoYInflation_times(void * jarg1) {
  void * jresult ;
  PiecewiseYoYInflationCurve< Linear > *arg1 = (PiecewiseYoYInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseYoYInflationCurve<Linear> > *)jarg1;
  arg1 = (PiecewiseYoYInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseYoYInflationCurve< Linear > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseYoYInflation_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseYoYInflationCurve< Linear > *arg1 = (PiecewiseYoYInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseYoYInflationCurve<Linear> > *)jarg1;
  arg1 = (PiecewiseYoYInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseYoYInflationCurve< Linear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PiecewiseYoYInflation(void * jarg1) {
  PiecewiseYoYInflationCurve< Linear > *arg1 = (PiecewiseYoYInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseYoYInflationCurve<Linear> > *)jarg1;
  arg1 = (PiecewiseYoYInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DatePair__SWIG_0() {
  void * jresult ;
  std::pair< Date,Date > *result = 0 ;
  
  {
    try {
      result = (std::pair< Date,Date > *)new std::pair< Date,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_DatePair__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  Date arg1 ;
  Date arg2 ;
  Date *argp1 ;
  Date *argp2 ;
  std::pair< Date,Date > *result = 0 ;
  
  argp1 = (Date *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg1 = *argp1; 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (std::pair< Date,Date > *)new std::pair< Date,Date >(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_DatePair__SWIG_2(void * jarg1) {
  void * jresult ;
  std::pair< Date,Date > *arg1 = 0 ;
  std::pair< Date,Date > *result = 0 ;
  
  arg1 = (std::pair< Date,Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Date,Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::pair< Date,Date > *)new std::pair< Date,Date >((std::pair< Date,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_DatePair_first_set(void * jarg1, void * jarg2) {
  std::pair< Date,Date > *arg1 = (std::pair< Date,Date > *) 0 ;
  Date *arg2 = (Date *) 0 ;
  
  arg1 = (std::pair< Date,Date > *)jarg1; 
  arg2 = (Date *)jarg2; 
  if (arg1) (arg1)->first = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DatePair_first_get(void * jarg1) {
  void * jresult ;
  std::pair< Date,Date > *arg1 = (std::pair< Date,Date > *) 0 ;
  Date *result = 0 ;
  
  arg1 = (std::pair< Date,Date > *)jarg1; 
  result = (Date *)& ((arg1)->first);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DatePair_second_set(void * jarg1, void * jarg2) {
  std::pair< Date,Date > *arg1 = (std::pair< Date,Date > *) 0 ;
  Date *arg2 = (Date *) 0 ;
  
  arg1 = (std::pair< Date,Date > *)jarg1; 
  arg2 = (Date *)jarg2; 
  if (arg1) (arg1)->second = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DatePair_second_get(void * jarg1) {
  void * jresult ;
  std::pair< Date,Date > *arg1 = (std::pair< Date,Date > *) 0 ;
  Date *result = 0 ;
  
  arg1 = (std::pair< Date,Date > *)jarg1; 
  result = (Date *)& ((arg1)->second);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DatePair(void * jarg1) {
  std::pair< Date,Date > *arg1 = (std::pair< Date,Date > *) 0 ;
  
  arg1 = (std::pair< Date,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_inflationPeriod(void * jarg1, int jarg2) {
  void * jresult ;
  Date *arg1 = 0 ;
  Frequency arg2 ;
  std::pair< Date,Date > result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Frequency)jarg2; 
  {
    try {
      result = inflationPeriod((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 std::pair< Date,Date >(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_inflationYearFraction(int jarg1, unsigned int jarg2, void * jarg3, void * jarg4, void * jarg5) {
  double jresult ;
  Frequency arg1 ;
  bool arg2 ;
  DayCounter *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Time result;
  
  arg1 = (Frequency)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)inflationYearFraction(arg1,arg2,(DayCounter 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 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 & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationCouponPricer(void * jarg1) {
  YoYInflationCouponPricer *arg1 = (YoYInflationCouponPricer *) 0 ;
  ext::shared_ptr< YoYInflationCouponPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YoYInflationCouponPricer > *)jarg1;
  arg1 = (YoYInflationCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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__SWIG_2(void * jarg1, void * jarg2) {
  Leg *arg1 = 0 ;
  ext::shared_ptr< YoYInflationCouponPricer > *arg2 = 0 ;
  ext::shared_ptr< YoYInflationCouponPricer > tempnull2 ;
  
  arg1 = (Leg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return ;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< YoYInflationCouponPricer > *)jarg2 : &tempnull2; 
  {
    try {
      setCouponPricer((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(ext::shared_ptr< YoYInflationCouponPricer > 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_YoYInflationCoupon__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, double jarg10, void * jarg11, void * jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Spread arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull6 ;
  YoYInflationCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< YoYInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Spread)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationCoupon *)new YoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter const &)*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 = result ? new ext::shared_ptr<  YoYInflationCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationCoupon__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, double jarg10, void * jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Spread arg10 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull6 ;
  YoYInflationCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< YoYInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Spread)jarg10; 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationCoupon *)new YoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter const &)*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 = result ? new ext::shared_ptr<  YoYInflationCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationCoupon__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, double jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Spread arg10 ;
  ext::shared_ptr< YoYInflationIndex > tempnull6 ;
  YoYInflationCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< YoYInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Spread)jarg10; 
  {
    try {
      result = (YoYInflationCoupon *)new YoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter 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 = result ? new ext::shared_ptr<  YoYInflationCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationCoupon__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  ext::shared_ptr< YoYInflationIndex > tempnull6 ;
  YoYInflationCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< YoYInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (YoYInflationCoupon *)new YoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter 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 = result ? new ext::shared_ptr<  YoYInflationCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationCoupon__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull6 ;
  YoYInflationCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< YoYInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationCoupon *)new YoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*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 = result ? new ext::shared_ptr<  YoYInflationCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationCoupon_gearing(void * jarg1) {
  double jresult ;
  YoYInflationCoupon *arg1 = (YoYInflationCoupon *) 0 ;
  ext::shared_ptr< YoYInflationCoupon const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationCoupon > *)jarg1;
  arg1 = (YoYInflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((YoYInflationCoupon const *)arg1)->gearing();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationCoupon_spread(void * jarg1) {
  double jresult ;
  YoYInflationCoupon *arg1 = (YoYInflationCoupon *) 0 ;
  ext::shared_ptr< YoYInflationCoupon const > *smartarg1 = 0 ;
  Spread result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationCoupon > *)jarg1;
  arg1 = (YoYInflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Spread)((YoYInflationCoupon const *)arg1)->spread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYInflationCoupon_adjustedFixing(void * jarg1) {
  double jresult ;
  YoYInflationCoupon *arg1 = (YoYInflationCoupon *) 0 ;
  ext::shared_ptr< YoYInflationCoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationCoupon > *)jarg1;
  arg1 = (YoYInflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((YoYInflationCoupon const *)arg1)->adjustedFixing();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationCoupon_yoyIndex(void * jarg1) {
  void * jresult ;
  YoYInflationCoupon *arg1 = (YoYInflationCoupon *) 0 ;
  ext::shared_ptr< YoYInflationCoupon const > *smartarg1 = 0 ;
  ext::shared_ptr< YoYInflationIndex > result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationCoupon > *)jarg1;
  arg1 = (YoYInflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((YoYInflationCoupon const *)arg1)->yoyIndex();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< YoYInflationIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationCoupon(void * jarg1) {
  YoYInflationCoupon *arg1 = (YoYInflationCoupon *) 0 ;
  ext::shared_ptr< YoYInflationCoupon > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YoYInflationCoupon > *)jarg1;
  arg1 = (YoYInflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_yoy_inflation_coupon(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  ext::shared_ptr< CashFlow > tempnull1 ;
  ext::shared_ptr< YoYInflationCoupon > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< CashFlow > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_yoy_inflation_coupon((ext::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 = result ? new ext::shared_ptr< YoYInflationCoupon >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredYoYInflationCoupon__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, double jarg10, double jarg11, double jarg12, void * jarg13, void * jarg14) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Spread arg10 ;
  Rate arg11 ;
  Rate arg12 ;
  Date *arg13 = 0 ;
  Date *arg14 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull6 ;
  CappedFlooredYoYInflationCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< YoYInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Spread)jarg10; 
  arg11 = (Rate)jarg11; 
  arg12 = (Rate)jarg12; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (Date *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredYoYInflationCoupon *)new CappedFlooredYoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter const &)*arg8,arg9,arg10,arg11,arg12,(Date const &)*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 = result ? new ext::shared_ptr<  CappedFlooredYoYInflationCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredYoYInflationCoupon__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, double jarg10, double jarg11, double jarg12, void * jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Spread arg10 ;
  Rate arg11 ;
  Rate arg12 ;
  Date *arg13 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull6 ;
  CappedFlooredYoYInflationCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< YoYInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Spread)jarg10; 
  arg11 = (Rate)jarg11; 
  arg12 = (Rate)jarg12; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredYoYInflationCoupon *)new CappedFlooredYoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter const &)*arg8,arg9,arg10,arg11,arg12,(Date 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 = result ? new ext::shared_ptr<  CappedFlooredYoYInflationCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredYoYInflationCoupon__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, double jarg10, double jarg11, double jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Spread arg10 ;
  Rate arg11 ;
  Rate arg12 ;
  ext::shared_ptr< YoYInflationIndex > tempnull6 ;
  CappedFlooredYoYInflationCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< YoYInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Spread)jarg10; 
  arg11 = (Rate)jarg11; 
  arg12 = (Rate)jarg12; 
  {
    try {
      result = (CappedFlooredYoYInflationCoupon *)new CappedFlooredYoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter 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 = result ? new ext::shared_ptr<  CappedFlooredYoYInflationCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredYoYInflationCoupon__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, double jarg10, double jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Spread arg10 ;
  Rate arg11 ;
  ext::shared_ptr< YoYInflationIndex > tempnull6 ;
  CappedFlooredYoYInflationCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< YoYInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Spread)jarg10; 
  arg11 = (Rate)jarg11; 
  {
    try {
      result = (CappedFlooredYoYInflationCoupon *)new CappedFlooredYoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter 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 = result ? new ext::shared_ptr<  CappedFlooredYoYInflationCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredYoYInflationCoupon__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, double jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Spread arg10 ;
  ext::shared_ptr< YoYInflationIndex > tempnull6 ;
  CappedFlooredYoYInflationCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< YoYInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Spread)jarg10; 
  {
    try {
      result = (CappedFlooredYoYInflationCoupon *)new CappedFlooredYoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter 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 = result ? new ext::shared_ptr<  CappedFlooredYoYInflationCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredYoYInflationCoupon__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  ext::shared_ptr< YoYInflationIndex > tempnull6 ;
  CappedFlooredYoYInflationCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< YoYInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (CappedFlooredYoYInflationCoupon *)new CappedFlooredYoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter 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 = result ? new ext::shared_ptr<  CappedFlooredYoYInflationCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CappedFlooredYoYInflationCoupon__SWIG_6(void * jarg1, double jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull6 ;
  CappedFlooredYoYInflationCoupon *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Natural)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< YoYInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (Period *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CappedFlooredYoYInflationCoupon *)new CappedFlooredYoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*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 = result ? new ext::shared_ptr<  CappedFlooredYoYInflationCoupon >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CappedFlooredYoYInflationCoupon_rate(void * jarg1) {
  double jresult ;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CappedFlooredYoYInflationCoupon > *)jarg1;
  arg1 = (CappedFlooredYoYInflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CappedFlooredYoYInflationCoupon 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 double SWIGSTDCALL CSharp_QuantLib_CappedFlooredYoYInflationCoupon_cap(void * jarg1) {
  double jresult ;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CappedFlooredYoYInflationCoupon > *)jarg1;
  arg1 = (CappedFlooredYoYInflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CappedFlooredYoYInflationCoupon const *)arg1)->cap();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CappedFlooredYoYInflationCoupon_floor(void * jarg1) {
  double jresult ;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CappedFlooredYoYInflationCoupon > *)jarg1;
  arg1 = (CappedFlooredYoYInflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CappedFlooredYoYInflationCoupon const *)arg1)->floor();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CappedFlooredYoYInflationCoupon_effectiveCap(void * jarg1) {
  double jresult ;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CappedFlooredYoYInflationCoupon > *)jarg1;
  arg1 = (CappedFlooredYoYInflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CappedFlooredYoYInflationCoupon const *)arg1)->effectiveCap();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CappedFlooredYoYInflationCoupon_effectiveFloor(void * jarg1) {
  double jresult ;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CappedFlooredYoYInflationCoupon > *)jarg1;
  arg1 = (CappedFlooredYoYInflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CappedFlooredYoYInflationCoupon const *)arg1)->effectiveFloor();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CappedFlooredYoYInflationCoupon_underlyingRate(void * jarg1) {
  double jresult ;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CappedFlooredYoYInflationCoupon > *)jarg1;
  arg1 = (CappedFlooredYoYInflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CappedFlooredYoYInflationCoupon const *)arg1)->underlyingRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_CappedFlooredYoYInflationCoupon_isCapped(void * jarg1) {
  unsigned int jresult ;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const CappedFlooredYoYInflationCoupon > *)jarg1;
  arg1 = (CappedFlooredYoYInflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((CappedFlooredYoYInflationCoupon const *)arg1)->isCapped();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_CappedFlooredYoYInflationCoupon_isFloored(void * jarg1) {
  unsigned int jresult ;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const CappedFlooredYoYInflationCoupon > *)jarg1;
  arg1 = (CappedFlooredYoYInflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((CappedFlooredYoYInflationCoupon const *)arg1)->isFloored();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_CappedFlooredYoYInflationCoupon(void * jarg1) {
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CappedFlooredYoYInflationCoupon > *)jarg1;
  arg1 = (CappedFlooredYoYInflationCoupon *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_capped_floored_yoy_inflation_coupon(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  ext::shared_ptr< CashFlow > tempnull1 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< CashFlow > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_capped_floored_yoy_inflation_coupon((ext::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 = result ? new ext::shared_ptr< CappedFlooredYoYInflationCoupon >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_yoyInflationLeg__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, unsigned int jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg3 = 0 ;
  Period *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Natural arg8 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  std::vector< Rate > *arg12 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< YoYInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Natural)jarg8; 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = (std::vector< Rate > *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _yoyInflationLeg((Schedule const &)*arg1,(Calendar const &)*arg2,(ext::shared_ptr< YoYInflationIndex > const &)*arg3,(Period const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< double > const &)*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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_yoyInflationLeg__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, unsigned int jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg3 = 0 ;
  Period *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Natural arg8 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  std::vector< Rate > *arg11 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< YoYInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Natural)jarg8; 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _yoyInflationLeg((Schedule const &)*arg1,(Calendar const &)*arg2,(ext::shared_ptr< YoYInflationIndex > const &)*arg3,(Period const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,arg7,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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_yoyInflationLeg__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, unsigned int jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg3 = 0 ;
  Period *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Natural arg8 ;
  std::vector< Real > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< YoYInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Natural)jarg8; 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _yoyInflationLeg((Schedule const &)*arg1,(Calendar const &)*arg2,(ext::shared_ptr< YoYInflationIndex > const &)*arg3,(Period const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,arg7,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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_yoyInflationLeg__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, unsigned int jarg8, void * jarg9) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg3 = 0 ;
  Period *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Natural arg8 ;
  std::vector< Real > *arg9 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< YoYInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Natural)jarg8; 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _yoyInflationLeg((Schedule const &)*arg1,(Calendar const &)*arg2,(ext::shared_ptr< YoYInflationIndex > const &)*arg3,(Period const &)*arg4,(std::vector< double > const &)*arg5,(DayCounter const &)*arg6,arg7,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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_yoyInflationLeg__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7, unsigned int jarg8) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg3 = 0 ;
  Period *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Natural arg8 ;
  ext::shared_ptr< YoYInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< YoYInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Natural)jarg8; 
  {
    try {
      result = _yoyInflationLeg((Schedule const &)*arg1,(Calendar const &)*arg2,(ext::shared_ptr< YoYInflationIndex > const &)*arg3,(Period 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_yoyInflationLeg__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, int jarg7) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg3 = 0 ;
  Period *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  ext::shared_ptr< YoYInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< YoYInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  {
    try {
      result = _yoyInflationLeg((Schedule const &)*arg1,(Calendar const &)*arg2,(ext::shared_ptr< YoYInflationIndex > const &)*arg3,(Period 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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_yoyInflationLeg__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Schedule *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg3 = 0 ;
  Period *arg4 = 0 ;
  std::vector< Real > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull3 ;
  Leg result;
  
  arg1 = (Schedule *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< YoYInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _yoyInflationLeg((Schedule const &)*arg1,(Calendar const &)*arg2,(ext::shared_ptr< YoYInflationIndex > const &)*arg3,(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 = new Leg(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackYoYInflationCouponPricer(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  BlackYoYInflationCouponPricer *result = 0 ;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYOptionletVolatilitySurface > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackYoYInflationCouponPricer *)new BlackYoYInflationCouponPricer((Handle< YoYOptionletVolatilitySurface > 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 ? new ext::shared_ptr<  BlackYoYInflationCouponPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackYoYInflationCouponPricer(void * jarg1) {
  BlackYoYInflationCouponPricer *arg1 = (BlackYoYInflationCouponPricer *) 0 ;
  ext::shared_ptr< BlackYoYInflationCouponPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackYoYInflationCouponPricer > *)jarg1;
  arg1 = (BlackYoYInflationCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UnitDisplacedBlackYoYInflationCouponPricer(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  UnitDisplacedBlackYoYInflationCouponPricer *result = 0 ;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYOptionletVolatilitySurface > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (UnitDisplacedBlackYoYInflationCouponPricer *)new UnitDisplacedBlackYoYInflationCouponPricer((Handle< YoYOptionletVolatilitySurface > 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 ? new ext::shared_ptr<  UnitDisplacedBlackYoYInflationCouponPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UnitDisplacedBlackYoYInflationCouponPricer(void * jarg1) {
  UnitDisplacedBlackYoYInflationCouponPricer *arg1 = (UnitDisplacedBlackYoYInflationCouponPricer *) 0 ;
  ext::shared_ptr< UnitDisplacedBlackYoYInflationCouponPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  UnitDisplacedBlackYoYInflationCouponPricer > *)jarg1;
  arg1 = (UnitDisplacedBlackYoYInflationCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BachelierYoYInflationCouponPricer(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YoYOptionletVolatilitySurface > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  BachelierYoYInflationCouponPricer *result = 0 ;
  
  arg1 = (Handle< YoYOptionletVolatilitySurface > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYOptionletVolatilitySurface > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BachelierYoYInflationCouponPricer *)new BachelierYoYInflationCouponPricer((Handle< YoYOptionletVolatilitySurface > 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 ? new ext::shared_ptr<  BachelierYoYInflationCouponPricer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BachelierYoYInflationCouponPricer(void * jarg1) {
  BachelierYoYInflationCouponPricer *arg1 = (BachelierYoYInflationCouponPricer *) 0 ;
  ext::shared_ptr< BachelierYoYInflationCouponPricer > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BachelierYoYInflationCouponPricer > *)jarg1;
  arg1 = (BachelierYoYInflationCouponPricer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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, int jarg11, unsigned int jarg12, void * jarg13, int jarg14) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  ext::shared_ptr< ZeroInflationIndex > *arg9 = 0 ;
  Period *arg10 = 0 ;
  CPI::InterpolationType arg11 ;
  bool arg12 ;
  SwigValueWrapper< Calendar > arg13 ;
  BusinessDayConvention arg14 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull9 ;
  Calendar *argp13 ;
  ZeroCouponInflationSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Rate)jarg8; 
  arg9 = jarg9 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg9 : &tempnull9; 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg11 = (CPI::InterpolationType)jarg11; 
  arg12 = jarg12 ? true : false; 
  argp13 = (Calendar *)jarg13; 
  if (!argp13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg13 = *argp13; 
  arg14 = (BusinessDayConvention)jarg14; 
  {
    try {
      result = (ZeroCouponInflationSwap *)new ZeroCouponInflationSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(Calendar const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,(ext::shared_ptr< ZeroInflationIndex > const &)*arg9,(Period const &)*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 = result ? new ext::shared_ptr<  ZeroCouponInflationSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, int jarg11, unsigned int jarg12, void * jarg13) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  ext::shared_ptr< ZeroInflationIndex > *arg9 = 0 ;
  Period *arg10 = 0 ;
  CPI::InterpolationType arg11 ;
  bool arg12 ;
  SwigValueWrapper< Calendar > arg13 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull9 ;
  Calendar *argp13 ;
  ZeroCouponInflationSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Rate)jarg8; 
  arg9 = jarg9 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg9 : &tempnull9; 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg11 = (CPI::InterpolationType)jarg11; 
  arg12 = jarg12 ? true : false; 
  argp13 = (Calendar *)jarg13; 
  if (!argp13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg13 = *argp13; 
  {
    try {
      result = (ZeroCouponInflationSwap *)new ZeroCouponInflationSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(Calendar const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,(ext::shared_ptr< ZeroInflationIndex > 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 = result ? new ext::shared_ptr<  ZeroCouponInflationSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, int jarg11, unsigned int jarg12) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  ext::shared_ptr< ZeroInflationIndex > *arg9 = 0 ;
  Period *arg10 = 0 ;
  CPI::InterpolationType arg11 ;
  bool arg12 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull9 ;
  ZeroCouponInflationSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Rate)jarg8; 
  arg9 = jarg9 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg9 : &tempnull9; 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg11 = (CPI::InterpolationType)jarg11; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (ZeroCouponInflationSwap *)new ZeroCouponInflationSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(Calendar const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,(ext::shared_ptr< ZeroInflationIndex > 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 = result ? new ext::shared_ptr<  ZeroCouponInflationSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, int jarg11) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  ext::shared_ptr< ZeroInflationIndex > *arg9 = 0 ;
  Period *arg10 = 0 ;
  CPI::InterpolationType arg11 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull9 ;
  ZeroCouponInflationSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Rate)jarg8; 
  arg9 = jarg9 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg9 : &tempnull9; 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg11 = (CPI::InterpolationType)jarg11; 
  {
    try {
      result = (ZeroCouponInflationSwap *)new ZeroCouponInflationSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(Calendar const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,(ext::shared_ptr< ZeroInflationIndex > 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 = result ? new ext::shared_ptr<  ZeroCouponInflationSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroCouponInflationSwap_fairRate(void * jarg1) {
  double jresult ;
  ZeroCouponInflationSwap *arg1 = (ZeroCouponInflationSwap *) 0 ;
  ext::shared_ptr< ZeroCouponInflationSwap > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr<  ZeroCouponInflationSwap > *)jarg1;
  arg1 = (ZeroCouponInflationSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)(arg1)->fairRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroCouponInflationSwap_fixedLegNPV(void * jarg1) {
  double jresult ;
  ZeroCouponInflationSwap *arg1 = (ZeroCouponInflationSwap *) 0 ;
  ext::shared_ptr< ZeroCouponInflationSwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  ZeroCouponInflationSwap > *)jarg1;
  arg1 = (ZeroCouponInflationSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->fixedLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ZeroCouponInflationSwap_inflationLegNPV(void * jarg1) {
  double jresult ;
  ZeroCouponInflationSwap *arg1 = (ZeroCouponInflationSwap *) 0 ;
  ext::shared_ptr< ZeroCouponInflationSwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  ZeroCouponInflationSwap > *)jarg1;
  arg1 = (ZeroCouponInflationSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->inflationLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  ZeroCouponInflationSwap *arg1 = (ZeroCouponInflationSwap *) 0 ;
  ext::shared_ptr< ZeroCouponInflationSwap > *smartarg1 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > > result;
  
  
  smartarg1 = (ext::shared_ptr<  ZeroCouponInflationSwap > *)jarg1;
  arg1 = (ZeroCouponInflationSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->fixedLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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< ext::shared_ptr< CashFlow > >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroCouponInflationSwap_inflationLeg(void * jarg1) {
  void * jresult ;
  ZeroCouponInflationSwap *arg1 = (ZeroCouponInflationSwap *) 0 ;
  ext::shared_ptr< ZeroCouponInflationSwap > *smartarg1 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > > result;
  
  
  smartarg1 = (ext::shared_ptr<  ZeroCouponInflationSwap > *)jarg1;
  arg1 = (ZeroCouponInflationSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->inflationLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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< ext::shared_ptr< CashFlow > >(result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_ZeroCouponInflationSwap_type(void * jarg1) {
  int jresult ;
  ZeroCouponInflationSwap *arg1 = (ZeroCouponInflationSwap *) 0 ;
  ext::shared_ptr< ZeroCouponInflationSwap > *smartarg1 = 0 ;
  Swap::Type result;
  
  
  smartarg1 = (ext::shared_ptr<  ZeroCouponInflationSwap > *)jarg1;
  arg1 = (ZeroCouponInflationSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Swap::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_delete_ZeroCouponInflationSwap(void * jarg1) {
  ZeroCouponInflationSwap *arg1 = (ZeroCouponInflationSwap *) 0 ;
  ext::shared_ptr< ZeroCouponInflationSwap > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZeroCouponInflationSwap > *)jarg1;
  arg1 = (ZeroCouponInflationSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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 ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  Spread arg9 ;
  DayCounter *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  BusinessDayConvention arg12 ;
  ext::shared_ptr< YoYInflationIndex > tempnull7 ;
  YearOnYearInflationSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Schedule *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< YoYInflationIndex > *)jarg7 : &tempnull7; 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg9 = (Spread)jarg9; 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg12 = (BusinessDayConvention)jarg12; 
  {
    try {
      result = (YearOnYearInflationSwap *)new YearOnYearInflationSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(ext::shared_ptr< YoYInflationIndex > 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 = result ? new ext::shared_ptr<  YearOnYearInflationSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  Spread arg9 ;
  DayCounter *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull7 ;
  YearOnYearInflationSwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (Rate)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Schedule *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< YoYInflationIndex > *)jarg7 : &tempnull7; 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg9 = (Spread)jarg9; 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YearOnYearInflationSwap *)new YearOnYearInflationSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(ext::shared_ptr< YoYInflationIndex > 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 = result ? new ext::shared_ptr<  YearOnYearInflationSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YearOnYearInflationSwap_fairRate(void * jarg1) {
  double jresult ;
  YearOnYearInflationSwap *arg1 = (YearOnYearInflationSwap *) 0 ;
  ext::shared_ptr< YearOnYearInflationSwap > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr<  YearOnYearInflationSwap > *)jarg1;
  arg1 = (YearOnYearInflationSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)(arg1)->fairRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YearOnYearInflationSwap_fixedLegNPV(void * jarg1) {
  double jresult ;
  YearOnYearInflationSwap *arg1 = (YearOnYearInflationSwap *) 0 ;
  ext::shared_ptr< YearOnYearInflationSwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  YearOnYearInflationSwap > *)jarg1;
  arg1 = (YearOnYearInflationSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->fixedLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YearOnYearInflationSwap_yoyLegNPV(void * jarg1) {
  double jresult ;
  YearOnYearInflationSwap *arg1 = (YearOnYearInflationSwap *) 0 ;
  ext::shared_ptr< YearOnYearInflationSwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  YearOnYearInflationSwap > *)jarg1;
  arg1 = (YearOnYearInflationSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->yoyLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YearOnYearInflationSwap_fairSpread(void * jarg1) {
  double jresult ;
  YearOnYearInflationSwap *arg1 = (YearOnYearInflationSwap *) 0 ;
  ext::shared_ptr< YearOnYearInflationSwap > *smartarg1 = 0 ;
  Spread result;
  
  
  smartarg1 = (ext::shared_ptr<  YearOnYearInflationSwap > *)jarg1;
  arg1 = (YearOnYearInflationSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Spread)(arg1)->fairSpread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YearOnYearInflationSwap_fixedLeg(void * jarg1) {
  void * jresult ;
  YearOnYearInflationSwap *arg1 = (YearOnYearInflationSwap *) 0 ;
  ext::shared_ptr< YearOnYearInflationSwap > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YearOnYearInflationSwap > *)jarg1;
  arg1 = (YearOnYearInflationSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &(arg1)->fixedLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YearOnYearInflationSwap_yoyLeg(void * jarg1) {
  void * jresult ;
  YearOnYearInflationSwap *arg1 = (YearOnYearInflationSwap *) 0 ;
  ext::shared_ptr< YearOnYearInflationSwap > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YearOnYearInflationSwap > *)jarg1;
  arg1 = (YearOnYearInflationSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &(arg1)->yoyLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YearOnYearInflationSwap(void * jarg1) {
  YearOnYearInflationSwap *arg1 = (YearOnYearInflationSwap *) 0 ;
  ext::shared_ptr< YearOnYearInflationSwap > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YearOnYearInflationSwap > *)jarg1;
  arg1 = (YearOnYearInflationSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPISwap__SWIG_0(int jarg1, double jarg2, unsigned int jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, unsigned int jarg8, void * jarg9, double jarg10, double jarg11, void * jarg12, void * jarg13, int jarg14, void * jarg15, void * jarg16, int jarg17, double jarg18) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  bool arg3 ;
  Spread arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  BusinessDayConvention *arg7 = 0 ;
  Natural arg8 ;
  ext::shared_ptr< IborIndex > *arg9 = 0 ;
  Rate arg10 ;
  Real arg11 ;
  DayCounter *arg12 = 0 ;
  Schedule *arg13 = 0 ;
  BusinessDayConvention *arg14 = 0 ;
  Period *arg15 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg16 = 0 ;
  CPI::InterpolationType arg17 ;
  Real arg18 ;
  BusinessDayConvention temp7 ;
  ext::shared_ptr< IborIndex > tempnull9 ;
  BusinessDayConvention temp14 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull16 ;
  CPISwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Spread)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Schedule *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  temp7 = (BusinessDayConvention)jarg7; 
  arg7 = &temp7; 
  arg8 = (Natural)jarg8; 
  arg9 = jarg9 ? (ext::shared_ptr< IborIndex > *)jarg9 : &tempnull9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (DayCounter *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg13 = (Schedule *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  temp14 = (BusinessDayConvention)jarg14; 
  arg14 = &temp14; 
  arg15 = (Period *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg16 = jarg16 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg16 : &tempnull16; 
  arg17 = (CPI::InterpolationType)jarg17; 
  arg18 = (Real)jarg18; 
  {
    try {
      result = (CPISwap *)new CPISwap(arg1,arg2,arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(BusinessDayConvention const &)*arg7,arg8,(ext::shared_ptr< IborIndex > const &)*arg9,arg10,arg11,(DayCounter const &)*arg12,(Schedule const &)*arg13,(BusinessDayConvention const &)*arg14,(Period const &)*arg15,(ext::shared_ptr< ZeroInflationIndex > const &)*arg16,arg17,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 = result ? new ext::shared_ptr<  CPISwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPISwap__SWIG_1(int jarg1, double jarg2, unsigned int jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, unsigned int jarg8, void * jarg9, double jarg10, double jarg11, void * jarg12, void * jarg13, int jarg14, void * jarg15, void * jarg16, int jarg17) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  bool arg3 ;
  Spread arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  BusinessDayConvention *arg7 = 0 ;
  Natural arg8 ;
  ext::shared_ptr< IborIndex > *arg9 = 0 ;
  Rate arg10 ;
  Real arg11 ;
  DayCounter *arg12 = 0 ;
  Schedule *arg13 = 0 ;
  BusinessDayConvention *arg14 = 0 ;
  Period *arg15 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg16 = 0 ;
  CPI::InterpolationType arg17 ;
  BusinessDayConvention temp7 ;
  ext::shared_ptr< IborIndex > tempnull9 ;
  BusinessDayConvention temp14 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull16 ;
  CPISwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Spread)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Schedule *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  temp7 = (BusinessDayConvention)jarg7; 
  arg7 = &temp7; 
  arg8 = (Natural)jarg8; 
  arg9 = jarg9 ? (ext::shared_ptr< IborIndex > *)jarg9 : &tempnull9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (DayCounter *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg13 = (Schedule *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  temp14 = (BusinessDayConvention)jarg14; 
  arg14 = &temp14; 
  arg15 = (Period *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg16 = jarg16 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg16 : &tempnull16; 
  arg17 = (CPI::InterpolationType)jarg17; 
  {
    try {
      result = (CPISwap *)new CPISwap(arg1,arg2,arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(BusinessDayConvention const &)*arg7,arg8,(ext::shared_ptr< IborIndex > const &)*arg9,arg10,arg11,(DayCounter const &)*arg12,(Schedule const &)*arg13,(BusinessDayConvention const &)*arg14,(Period const &)*arg15,(ext::shared_ptr< ZeroInflationIndex > const &)*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 = result ? new ext::shared_ptr<  CPISwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CPISwap__SWIG_2(int jarg1, double jarg2, unsigned int jarg3, double jarg4, void * jarg5, void * jarg6, int jarg7, unsigned int jarg8, void * jarg9, double jarg10, double jarg11, void * jarg12, void * jarg13, int jarg14, void * jarg15, void * jarg16) {
  void * jresult ;
  Swap::Type arg1 ;
  Real arg2 ;
  bool arg3 ;
  Spread arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  BusinessDayConvention *arg7 = 0 ;
  Natural arg8 ;
  ext::shared_ptr< IborIndex > *arg9 = 0 ;
  Rate arg10 ;
  Real arg11 ;
  DayCounter *arg12 = 0 ;
  Schedule *arg13 = 0 ;
  BusinessDayConvention *arg14 = 0 ;
  Period *arg15 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg16 = 0 ;
  BusinessDayConvention temp7 ;
  ext::shared_ptr< IborIndex > tempnull9 ;
  BusinessDayConvention temp14 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull16 ;
  CPISwap *result = 0 ;
  
  arg1 = (Swap::Type)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (Spread)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Schedule *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  temp7 = (BusinessDayConvention)jarg7; 
  arg7 = &temp7; 
  arg8 = (Natural)jarg8; 
  arg9 = jarg9 ? (ext::shared_ptr< IborIndex > *)jarg9 : &tempnull9; 
  arg10 = (Rate)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (DayCounter *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg13 = (Schedule *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  temp14 = (BusinessDayConvention)jarg14; 
  arg14 = &temp14; 
  arg15 = (Period *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg16 = jarg16 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg16 : &tempnull16; 
  {
    try {
      result = (CPISwap *)new CPISwap(arg1,arg2,arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(BusinessDayConvention const &)*arg7,arg8,(ext::shared_ptr< IborIndex > const &)*arg9,arg10,arg11,(DayCounter const &)*arg12,(Schedule const &)*arg13,(BusinessDayConvention const &)*arg14,(Period const &)*arg15,(ext::shared_ptr< ZeroInflationIndex > 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 = result ? new ext::shared_ptr<  CPISwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CPISwap_fairRate(void * jarg1) {
  double jresult ;
  CPISwap *arg1 = (CPISwap *) 0 ;
  ext::shared_ptr< CPISwap > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr<  CPISwap > *)jarg1;
  arg1 = (CPISwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)(arg1)->fairRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CPISwap_floatLegNPV(void * jarg1) {
  double jresult ;
  CPISwap *arg1 = (CPISwap *) 0 ;
  ext::shared_ptr< CPISwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CPISwap > *)jarg1;
  arg1 = (CPISwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->floatLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CPISwap_fairSpread(void * jarg1) {
  double jresult ;
  CPISwap *arg1 = (CPISwap *) 0 ;
  ext::shared_ptr< CPISwap > *smartarg1 = 0 ;
  Spread result;
  
  
  smartarg1 = (ext::shared_ptr<  CPISwap > *)jarg1;
  arg1 = (CPISwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Spread)(arg1)->fairSpread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CPISwap_fixedLegNPV(void * jarg1) {
  double jresult ;
  CPISwap *arg1 = (CPISwap *) 0 ;
  ext::shared_ptr< CPISwap > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CPISwap > *)jarg1;
  arg1 = (CPISwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->fixedLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPISwap_cpiLeg(void * jarg1) {
  void * jresult ;
  CPISwap *arg1 = (CPISwap *) 0 ;
  ext::shared_ptr< CPISwap > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CPISwap > *)jarg1;
  arg1 = (CPISwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &(arg1)->cpiLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CPISwap_floatLeg(void * jarg1) {
  void * jresult ;
  CPISwap *arg1 = (CPISwap *) 0 ;
  ext::shared_ptr< CPISwap > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CPISwap > *)jarg1;
  arg1 = (CPISwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &(arg1)->floatLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CPISwap(void * jarg1) {
  CPISwap *arg1 = (CPISwap *) 0 ;
  ext::shared_ptr< CPISwap > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CPISwap > *)jarg1;
  arg1 = (CPISwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationCapFloor(int jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  YoYInflationCapFloor::Type arg1 ;
  Leg *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  YoYInflationCapFloor *result = 0 ;
  
  arg1 = (YoYInflationCapFloor::Type)jarg1; 
  arg2 = (Leg *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationCapFloor *)new YoYInflationCapFloor(arg1,(Leg const &)*arg2,(std::vector< Rate > 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 ? new ext::shared_ptr<  YoYInflationCapFloor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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 ;
  YoYInflationCapFloor *arg1 = (YoYInflationCapFloor *) 0 ;
  Real arg2 ;
  Handle< YoYInflationTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Size arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  ext::shared_ptr< YoYInflationCapFloor const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationCapFloor > *)jarg1;
  arg1 = (YoYInflationCapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YoYInflationTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Volatility)jarg7; 
  arg8 = (Volatility)jarg8; 
  {
    try {
      result = (Volatility)((YoYInflationCapFloor const *)arg1)->impliedVolatility(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 ;
  YoYInflationCapFloor *arg1 = (YoYInflationCapFloor *) 0 ;
  Real arg2 ;
  Handle< YoYInflationTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Size arg6 ;
  Volatility arg7 ;
  ext::shared_ptr< YoYInflationCapFloor const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationCapFloor > *)jarg1;
  arg1 = (YoYInflationCapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YoYInflationTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Volatility)jarg7; 
  {
    try {
      result = (Volatility)((YoYInflationCapFloor const *)arg1)->impliedVolatility(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 ;
  YoYInflationCapFloor *arg1 = (YoYInflationCapFloor *) 0 ;
  Real arg2 ;
  Handle< YoYInflationTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Size arg6 ;
  ext::shared_ptr< YoYInflationCapFloor const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationCapFloor > *)jarg1;
  arg1 = (YoYInflationCapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YoYInflationTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (Volatility)((YoYInflationCapFloor const *)arg1)->impliedVolatility(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 ;
  YoYInflationCapFloor *arg1 = (YoYInflationCapFloor *) 0 ;
  Real arg2 ;
  Handle< YoYInflationTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  ext::shared_ptr< YoYInflationCapFloor const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationCapFloor > *)jarg1;
  arg1 = (YoYInflationCapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YoYInflationTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Volatility)((YoYInflationCapFloor const *)arg1)->impliedVolatility(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 ;
  YoYInflationCapFloor *arg1 = (YoYInflationCapFloor *) 0 ;
  Real arg2 ;
  Handle< YoYInflationTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  ext::shared_ptr< YoYInflationCapFloor const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYInflationCapFloor > *)jarg1;
  arg1 = (YoYInflationCapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YoYInflationTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYInflationTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  {
    try {
      result = (Volatility)((YoYInflationCapFloor const *)arg1)->impliedVolatility(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_YoYInflationCapFloor_optionletPrices(void * jarg1) {
  void * jresult ;
  YoYInflationCapFloor *arg1 = (YoYInflationCapFloor *) 0 ;
  ext::shared_ptr< YoYInflationCapFloor > *smartarg1 = 0 ;
  std::vector< Real > result;
  
  
  smartarg1 = (ext::shared_ptr<  YoYInflationCapFloor > *)jarg1;
  arg1 = (YoYInflationCapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = YoYInflationCapFloor_optionletPrices(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationCapFloor(void * jarg1) {
  YoYInflationCapFloor *arg1 = (YoYInflationCapFloor *) 0 ;
  ext::shared_ptr< YoYInflationCapFloor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YoYInflationCapFloor > *)jarg1;
  arg1 = (YoYInflationCapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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< ext::shared_ptr< CashFlow > > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  YoYInflationCap *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CashFlow > > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationCap *)new YoYInflationCap((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(std::vector< Rate > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  YoYInflationCap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationCap(void * jarg1) {
  YoYInflationCap *arg1 = (YoYInflationCap *) 0 ;
  ext::shared_ptr< YoYInflationCap > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YoYInflationCap > *)jarg1;
  arg1 = (YoYInflationCap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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< ext::shared_ptr< CashFlow > > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  YoYInflationFloor *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CashFlow > > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationFloor *)new YoYInflationFloor((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(std::vector< Rate > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  YoYInflationFloor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationFloor(void * jarg1) {
  YoYInflationFloor *arg1 = (YoYInflationFloor *) 0 ;
  ext::shared_ptr< YoYInflationFloor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YoYInflationFloor > *)jarg1;
  arg1 = (YoYInflationFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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< ext::shared_ptr< CashFlow > > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  YoYInflationCollar *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CashFlow > > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationCollar *)new YoYInflationCollar((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Rate > 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 ? new ext::shared_ptr<  YoYInflationCollar >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationCollar(void * jarg1) {
  YoYInflationCollar *arg1 = (YoYInflationCollar *) 0 ;
  ext::shared_ptr< YoYInflationCollar > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YoYInflationCollar > *)jarg1;
  arg1 = (YoYInflationCollar *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroInflationCurve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  std::vector< Date > *arg6 = 0 ;
  std::vector< Rate > *arg7 = 0 ;
  Linear *arg8 = 0 ;
  InterpolatedZeroInflationCurve< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Rate > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg8 = (Linear *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroInflationCurve< Linear > *)new InterpolatedZeroInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,(std::vector< Date > const &)*arg6,(std::vector< Rate > const &)*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 = result ? new ext::shared_ptr<  InterpolatedZeroInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ZeroInflationCurve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  std::vector< Date > *arg6 = 0 ;
  std::vector< Rate > *arg7 = 0 ;
  InterpolatedZeroInflationCurve< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Rate > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroInflationCurve< Linear > *)new InterpolatedZeroInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,(std::vector< Date > const &)*arg6,(std::vector< Rate > 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 ? new ext::shared_ptr<  InterpolatedZeroInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationCurve_dates(void * jarg1) {
  void * jresult ;
  InterpolatedZeroInflationCurve< Linear > *arg1 = (InterpolatedZeroInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedZeroInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedZeroInflationCurve< Linear > 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_ZeroInflationCurve_times(void * jarg1) {
  void * jresult ;
  InterpolatedZeroInflationCurve< Linear > *arg1 = (InterpolatedZeroInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedZeroInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((InterpolatedZeroInflationCurve< Linear > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationCurve_data(void * jarg1) {
  void * jresult ;
  InterpolatedZeroInflationCurve< Linear > *arg1 = (InterpolatedZeroInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedZeroInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedZeroInflationCurve< Linear > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationCurve_rates(void * jarg1) {
  void * jresult ;
  InterpolatedZeroInflationCurve< Linear > *arg1 = (InterpolatedZeroInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedZeroInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Rate > *) &((InterpolatedZeroInflationCurve< Linear > const *)arg1)->rates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroInflationCurve_nodes(void * jarg1) {
  void * jresult ;
  InterpolatedZeroInflationCurve< Linear > *arg1 = (InterpolatedZeroInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedZeroInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedZeroInflationCurve< Linear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroInflationCurve(void * jarg1) {
  InterpolatedZeroInflationCurve< Linear > *arg1 = (InterpolatedZeroInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedZeroInflationCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedZeroInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationCurve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, unsigned int jarg6, void * jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  bool arg6 ;
  std::vector< Date > *arg7 = 0 ;
  std::vector< Rate > *arg8 = 0 ;
  Linear *arg9 = 0 ;
  InterpolatedYoYInflationCurve< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (std::vector< Date > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Rate > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg9 = (Linear *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedYoYInflationCurve< Linear > *)new InterpolatedYoYInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,(std::vector< Date > const &)*arg7,(std::vector< Rate > const &)*arg8,(Linear 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 ? new ext::shared_ptr<  InterpolatedYoYInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationCurve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, unsigned int jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  bool arg6 ;
  std::vector< Date > *arg7 = 0 ;
  std::vector< Rate > *arg8 = 0 ;
  InterpolatedYoYInflationCurve< Linear > *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Frequency)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (std::vector< Date > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg8 = (std::vector< Rate > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedYoYInflationCurve< Linear > *)new InterpolatedYoYInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,(std::vector< Date > const &)*arg7,(std::vector< Rate > 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 ? new ext::shared_ptr<  InterpolatedYoYInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationCurve_dates(void * jarg1) {
  void * jresult ;
  InterpolatedYoYInflationCurve< Linear > *arg1 = (InterpolatedYoYInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedYoYInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedYoYInflationCurve< Linear > 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_YoYInflationCurve_times(void * jarg1) {
  void * jresult ;
  InterpolatedYoYInflationCurve< Linear > *arg1 = (InterpolatedYoYInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedYoYInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((InterpolatedYoYInflationCurve< Linear > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationCurve_data(void * jarg1) {
  void * jresult ;
  InterpolatedYoYInflationCurve< Linear > *arg1 = (InterpolatedYoYInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedYoYInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedYoYInflationCurve< Linear > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationCurve_rates(void * jarg1) {
  void * jresult ;
  InterpolatedYoYInflationCurve< Linear > *arg1 = (InterpolatedYoYInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedYoYInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Rate > *) &((InterpolatedYoYInflationCurve< Linear > const *)arg1)->rates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYInflationCurve_nodes(void * jarg1) {
  void * jresult ;
  InterpolatedYoYInflationCurve< Linear > *arg1 = (InterpolatedYoYInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedYoYInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedYoYInflationCurve< Linear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationCurve(void * jarg1) {
  InterpolatedYoYInflationCurve< Linear > *arg1 = (InterpolatedYoYInflationCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedYoYInflationCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedYoYInflationCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_atmYoYSwapTimeRates(void * jarg1) {
  void * jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  std::pair< std::vector< Time >,std::vector< Rate > > result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((YoYCapFloorTermPriceSurface const *)arg1)->atmYoYSwapTimeRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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< std::vector< Time >,std::vector< Rate > >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_atmYoYSwapDateRates(void * jarg1) {
  void * jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  SwigValueWrapper< std::pair< std::vector< Date >,std::vector< double > > > result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((YoYCapFloorTermPriceSurface const *)arg1)->atmYoYSwapDateRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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< std::vector< Date >,std::vector< Rate > >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_YoYTS(void * jarg1) {
  void * jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((YoYCapFloorTermPriceSurface const *)arg1)->YoYTS();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< YoYInflationTermStructure >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_yoyIndex(void * jarg1) {
  void * jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  ext::shared_ptr< YoYInflationIndex > result;
  
  
  smartarg1 = (ext::shared_ptr<  YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->yoyIndex();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< YoYInflationIndex >(result) : 0; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_businessDayConvention(void * jarg1) {
  int jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  BusinessDayConvention result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (BusinessDayConvention)((YoYCapFloorTermPriceSurface const *)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 unsigned int SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_fixingDays(void * jarg1) {
  unsigned int jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  Natural result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Natural)((YoYCapFloorTermPriceSurface const *)arg1)->fixingDays();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_price__SWIG_0(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Real)(arg1)->price((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_YoYCapFloorTermPriceSurface_capPrice__SWIG_0(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Real)(arg1)->capPrice((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_YoYCapFloorTermPriceSurface_floorPrice__SWIG_0(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Real)(arg1)->floorPrice((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_YoYCapFloorTermPriceSurface_atmYoYSwapRate__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr<  YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Rate)(arg1)->atmYoYSwapRate((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_YoYCapFloorTermPriceSurface_atmYoYSwapRate__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr<  YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)(arg1)->atmYoYSwapRate((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_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr<  YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Rate)(arg1)->atmYoYRate((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_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr<  YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)(arg1)->atmYoYRate((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_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_2(void * jarg1, void * jarg2) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr<  YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)(arg1)->atmYoYRate((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_YoYCapFloorTermPriceSurface_price__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Real)((YoYCapFloorTermPriceSurface const *)arg1)->price((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_YoYCapFloorTermPriceSurface_capPrice__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Real)((YoYCapFloorTermPriceSurface const *)arg1)->capPrice((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_YoYCapFloorTermPriceSurface_floorPrice__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (Real)((YoYCapFloorTermPriceSurface const *)arg1)->floorPrice((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_YoYCapFloorTermPriceSurface_atmYoYSwapRate__SWIG_2(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  bool arg3 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (Rate)((YoYCapFloorTermPriceSurface const *)arg1)->atmYoYSwapRate((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_YoYCapFloorTermPriceSurface_atmYoYSwapRate__SWIG_3(void * jarg1, void * jarg2) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)((YoYCapFloorTermPriceSurface const *)arg1)->atmYoYSwapRate((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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Rate)((YoYCapFloorTermPriceSurface const *)arg1)->atmYoYRate((Period 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_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)((YoYCapFloorTermPriceSurface const *)arg1)->atmYoYRate((Period 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_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_5(void * jarg1, void * jarg2) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)((YoYCapFloorTermPriceSurface const *)arg1)->atmYoYRate((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 = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_strikes(void * jarg1) {
  void * jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  std::vector< Rate > result;
  
  
  smartarg1 = (ext::shared_ptr<  YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->strikes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_capStrikes(void * jarg1) {
  void * jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  std::vector< Rate > result;
  
  
  smartarg1 = (ext::shared_ptr<  YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->capStrikes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_floorStrikes(void * jarg1) {
  void * jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  std::vector< Rate > result;
  
  
  smartarg1 = (ext::shared_ptr<  YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->floorStrikes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_maturities(void * jarg1) {
  void * jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  std::vector< Period > result;
  
  
  smartarg1 = (ext::shared_ptr<  YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->maturities();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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< Period >(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_minStrike(void * jarg1) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((YoYCapFloorTermPriceSurface const *)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_YoYCapFloorTermPriceSurface_maxStrike(void * jarg1) {
  double jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((YoYCapFloorTermPriceSurface const *)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 void * SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_minMaturity(void * jarg1) {
  void * jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((YoYCapFloorTermPriceSurface const *)arg1)->minMaturity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_maxMaturity(void * jarg1) {
  void * jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((YoYCapFloorTermPriceSurface const *)arg1)->maxMaturity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_yoyOptionDateFromTenor(void * jarg1, void * jarg2) {
  void * jresult ;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((YoYCapFloorTermPriceSurface const *)arg1)->yoyOptionDateFromTenor((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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYCapFloorTermPriceSurface(void * jarg1) {
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YoYCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationCapFloorTermPriceSurface__SWIG_0(unsigned int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13, void * jarg14, void * jarg15) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg3 = 0 ;
  Rate arg4 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Period > *arg11 = 0 ;
  Matrix *arg12 = 0 ;
  Matrix *arg13 = 0 ;
  Bicubic *arg14 = 0 ;
  Cubic *arg15 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull3 ;
  BusinessDayConvention temp8 ;
  YoYInflationCapFloorTermPriceSurface *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< YoYInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Rate)jarg4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Calendar *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  temp8 = (BusinessDayConvention)jarg8; 
  arg8 = &temp8; 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Period > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg12 = (Matrix *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg13 = (Matrix *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg14 = (Bicubic *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bicubic const & is null", 0);
    return 0;
  } 
  arg15 = (Cubic *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationCapFloorTermPriceSurface *)new_YoYInflationCapFloorTermPriceSurface__SWIG_0(arg1,(Period const &)*arg2,(ext::shared_ptr< YoYInflationIndex > const &)*arg3,arg4,(Handle< YieldTermStructure > const &)*arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,(enum BusinessDayConvention const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< Period > const &)*arg11,(Matrix const &)*arg12,(Matrix const &)*arg13,(Bicubic const &)*arg14,(Cubic 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 = result ? new ext::shared_ptr<  YoYInflationCapFloorTermPriceSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationCapFloorTermPriceSurface__SWIG_1(unsigned int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13, void * jarg14) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg3 = 0 ;
  Rate arg4 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Period > *arg11 = 0 ;
  Matrix *arg12 = 0 ;
  Matrix *arg13 = 0 ;
  Bicubic *arg14 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull3 ;
  BusinessDayConvention temp8 ;
  YoYInflationCapFloorTermPriceSurface *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< YoYInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Rate)jarg4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Calendar *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  temp8 = (BusinessDayConvention)jarg8; 
  arg8 = &temp8; 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Period > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg12 = (Matrix *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg13 = (Matrix *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg14 = (Bicubic *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bicubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationCapFloorTermPriceSurface *)new_YoYInflationCapFloorTermPriceSurface__SWIG_0(arg1,(Period const &)*arg2,(ext::shared_ptr< YoYInflationIndex > const &)*arg3,arg4,(Handle< YieldTermStructure > const &)*arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,(enum BusinessDayConvention const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< Period > const &)*arg11,(Matrix const &)*arg12,(Matrix const &)*arg13,(Bicubic 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 = result ? new ext::shared_ptr<  YoYInflationCapFloorTermPriceSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationCapFloorTermPriceSurface__SWIG_2(unsigned int jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, int jarg8, void * jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg3 = 0 ;
  Rate arg4 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  std::vector< Period > *arg11 = 0 ;
  Matrix *arg12 = 0 ;
  Matrix *arg13 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull3 ;
  BusinessDayConvention temp8 ;
  YoYInflationCapFloorTermPriceSurface *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< YoYInflationIndex > *)jarg3 : &tempnull3; 
  arg4 = (Rate)jarg4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Calendar *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  temp8 = (BusinessDayConvention)jarg8; 
  arg8 = &temp8; 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Period > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg12 = (Matrix *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg13 = (Matrix *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationCapFloorTermPriceSurface *)new_YoYInflationCapFloorTermPriceSurface__SWIG_0(arg1,(Period const &)*arg2,(ext::shared_ptr< YoYInflationIndex > const &)*arg3,arg4,(Handle< YieldTermStructure > const &)*arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,(enum BusinessDayConvention const &)*arg8,(std::vector< double > const &)*arg9,(std::vector< double > const &)*arg10,(std::vector< Period > const &)*arg11,(Matrix const &)*arg12,(Matrix 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 = result ? new ext::shared_ptr<  YoYInflationCapFloorTermPriceSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationCapFloorTermPriceSurface(void * jarg1) {
  YoYInflationCapFloorTermPriceSurface *arg1 = (YoYInflationCapFloorTermPriceSurface *) 0 ;
  ext::shared_ptr< YoYInflationCapFloorTermPriceSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YoYInflationCapFloorTermPriceSurface > *)jarg1;
  arg1 = (YoYInflationCapFloorTermPriceSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationBlackCapFloorEngine(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< YoYInflationIndex > *arg1 = 0 ;
  Handle< YoYOptionletVolatilitySurface > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull1 ;
  YoYInflationBlackCapFloorEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< YoYInflationIndex > *)jarg1 : &tempnull1; 
  arg2 = (Handle< YoYOptionletVolatilitySurface > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYOptionletVolatilitySurface > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationBlackCapFloorEngine *)new YoYInflationBlackCapFloorEngine((ext::shared_ptr< YoYInflationIndex > const &)*arg1,(Handle< YoYOptionletVolatilitySurface > 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 = result ? new ext::shared_ptr<  YoYInflationBlackCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationBlackCapFloorEngine(void * jarg1) {
  YoYInflationBlackCapFloorEngine *arg1 = (YoYInflationBlackCapFloorEngine *) 0 ;
  ext::shared_ptr< YoYInflationBlackCapFloorEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YoYInflationBlackCapFloorEngine > *)jarg1;
  arg1 = (YoYInflationBlackCapFloorEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationUnitDisplacedBlackCapFloorEngine(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< YoYInflationIndex > *arg1 = 0 ;
  Handle< YoYOptionletVolatilitySurface > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull1 ;
  YoYInflationUnitDisplacedBlackCapFloorEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< YoYInflationIndex > *)jarg1 : &tempnull1; 
  arg2 = (Handle< YoYOptionletVolatilitySurface > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYOptionletVolatilitySurface > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationUnitDisplacedBlackCapFloorEngine *)new YoYInflationUnitDisplacedBlackCapFloorEngine((ext::shared_ptr< YoYInflationIndex > const &)*arg1,(Handle< YoYOptionletVolatilitySurface > 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 = result ? new ext::shared_ptr<  YoYInflationUnitDisplacedBlackCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationUnitDisplacedBlackCapFloorEngine(void * jarg1) {
  YoYInflationUnitDisplacedBlackCapFloorEngine *arg1 = (YoYInflationUnitDisplacedBlackCapFloorEngine *) 0 ;
  ext::shared_ptr< YoYInflationUnitDisplacedBlackCapFloorEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YoYInflationUnitDisplacedBlackCapFloorEngine > *)jarg1;
  arg1 = (YoYInflationUnitDisplacedBlackCapFloorEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYInflationBachelierCapFloorEngine(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< YoYInflationIndex > *arg1 = 0 ;
  Handle< YoYOptionletVolatilitySurface > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull1 ;
  YoYInflationBachelierCapFloorEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< YoYInflationIndex > *)jarg1 : &tempnull1; 
  arg2 = (Handle< YoYOptionletVolatilitySurface > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YoYOptionletVolatilitySurface > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (YoYInflationBachelierCapFloorEngine *)new YoYInflationBachelierCapFloorEngine((ext::shared_ptr< YoYInflationIndex > const &)*arg1,(Handle< YoYOptionletVolatilitySurface > 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 = result ? new ext::shared_ptr<  YoYInflationBachelierCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYInflationBachelierCapFloorEngine(void * jarg1) {
  YoYInflationBachelierCapFloorEngine *arg1 = (YoYInflationBachelierCapFloorEngine *) 0 ;
  ext::shared_ptr< YoYInflationBachelierCapFloorEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YoYInflationBachelierCapFloorEngine > *)jarg1;
  arg1 = (YoYInflationBachelierCapFloorEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_YoYOptionletHelper(void * jarg1, double jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6, unsigned int jarg7, void * jarg8, double jarg9, unsigned long jarg10, void * jarg11) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Real arg2 ;
  YoYInflationCapFloor::Type arg3 ;
  Period *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Calendar *arg6 = 0 ;
  Natural arg7 ;
  ext::shared_ptr< YoYInflationIndex > *arg8 = 0 ;
  Rate arg9 ;
  Size arg10 ;
  ext::shared_ptr< PricingEngine > *arg11 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempnull8 ;
  ext::shared_ptr< PricingEngine > tempnull11 ;
  YoYOptionletHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (YoYInflationCapFloor::Type)jarg3; 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (Calendar *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg7 = (Natural)jarg7; 
  arg8 = jarg8 ? (ext::shared_ptr< YoYInflationIndex > *)jarg8 : &tempnull8; 
  arg9 = (Rate)jarg9; 
  arg10 = (Size)jarg10; 
  arg11 = jarg11 ? (ext::shared_ptr< PricingEngine > *)jarg11 : &tempnull11; 
  {
    try {
      result = (YoYOptionletHelper *)new_YoYOptionletHelper((Handle< Quote > const &)*arg1,arg2,arg3,*arg4,(DayCounter const &)*arg5,(Calendar const &)*arg6,arg7,(ext::shared_ptr< YoYInflationIndex > const &)*arg8,arg9,SWIG_STD_MOVE(arg10),(ext::shared_ptr< PricingEngine > 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 = result ? new ext::shared_ptr<  YoYOptionletHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYOptionletHelper(void * jarg1) {
  YoYOptionletHelper *arg1 = (YoYOptionletHelper *) 0 ;
  ext::shared_ptr< YoYOptionletHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YoYOptionletHelper > *)jarg1;
  arg1 = (YoYOptionletHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_YoYOptionletStripper_initialize(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  YoYOptionletStripper *arg1 = (YoYOptionletStripper *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *arg2 = 0 ;
  ext::shared_ptr< PricingEngine > *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< YoYOptionletStripper const > *smartarg1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempnull2 ;
  ext::shared_ptr< PricingEngine > tempnull3 ;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletStripper > *)jarg1;
  arg1 = (YoYOptionletStripper *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (ext::shared_ptr< YoYCapFloorTermPriceSurface > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< PricingEngine > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  {
    try {
      YoYOptionletStripper_initialize((YoYOptionletStripper const *)arg1,(ext::shared_ptr< YoYCapFloorTermPriceSurface > const &)*arg2,(ext::shared_ptr< PricingEngine > const &)*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 double SWIGSTDCALL CSharp_QuantLib_YoYOptionletStripper_maxStrike(void * jarg1) {
  double jresult ;
  YoYOptionletStripper *arg1 = (YoYOptionletStripper *) 0 ;
  ext::shared_ptr< YoYOptionletStripper const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletStripper > *)jarg1;
  arg1 = (YoYOptionletStripper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((YoYOptionletStripper const *)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 void * SWIGSTDCALL CSharp_QuantLib_YoYOptionletStripper_strikes(void * jarg1) {
  void * jresult ;
  YoYOptionletStripper *arg1 = (YoYOptionletStripper *) 0 ;
  ext::shared_ptr< YoYOptionletStripper const > *smartarg1 = 0 ;
  std::vector< Rate > result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletStripper > *)jarg1;
  arg1 = (YoYOptionletStripper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((YoYOptionletStripper const *)arg1)->strikes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_YoYOptionletStripper_slice(void * jarg1, void * jarg2) {
  void * jresult ;
  YoYOptionletStripper *arg1 = (YoYOptionletStripper *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< YoYOptionletStripper const > *smartarg1 = 0 ;
  std::pair< std::vector< Rate >,std::vector< Volatility > > result;
  
  
  smartarg1 = (ext::shared_ptr< const YoYOptionletStripper > *)jarg1;
  arg1 = (YoYOptionletStripper *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((YoYOptionletStripper const *)arg1)->slice((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 std::pair< std::vector< Rate >,std::vector< Volatility > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_YoYOptionletStripper(void * jarg1) {
  YoYOptionletStripper *arg1 = (YoYOptionletStripper *) 0 ;
  ext::shared_ptr< YoYOptionletStripper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  YoYOptionletStripper > *)jarg1;
  arg1 = (YoYOptionletStripper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InterpolatedYoYInflationOptionletStripper() {
  void * jresult ;
  InterpolatedYoYOptionletStripper< Linear > *result = 0 ;
  
  {
    try {
      result = (InterpolatedYoYOptionletStripper< Linear > *)new InterpolatedYoYOptionletStripper< 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 = result ? new ext::shared_ptr<  InterpolatedYoYOptionletStripper<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InterpolatedYoYInflationOptionletStripper(void * jarg1) {
  InterpolatedYoYOptionletStripper< Linear > *arg1 = (InterpolatedYoYOptionletStripper< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedYoYOptionletStripper< Linear > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedYoYOptionletStripper<Linear> > *)jarg1;
  arg1 = (InterpolatedYoYOptionletStripper<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InterpolatedYoYInflationOptionletVolatilityCurve__SWIG_0(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9, double jarg10, double jarg11, void * jarg12) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  DayCounter *arg4 = 0 ;
  Period *arg5 = 0 ;
  Frequency arg6 ;
  bool arg7 ;
  std::vector< Date > *arg8 = 0 ;
  std::vector< Volatility > *arg9 = 0 ;
  Rate arg10 ;
  Rate arg11 ;
  Linear *arg12 = 0 ;
  InterpolatedYoYOptionletVolatilityCurve< Linear > *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (Frequency)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (std::vector< Date > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Volatility > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg10 = (Rate)jarg10; 
  arg11 = (Rate)jarg11; 
  arg12 = (Linear *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedYoYOptionletVolatilityCurve< Linear > *)new InterpolatedYoYOptionletVolatilityCurve< Linear >(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4,(Period const &)*arg5,arg6,arg7,(std::vector< Date > const &)*arg8,(std::vector< Volatility > const &)*arg9,arg10,arg11,(Linear 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 = result ? new ext::shared_ptr<  InterpolatedYoYOptionletVolatilityCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_InterpolatedYoYInflationOptionletVolatilityCurve__SWIG_1(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9, double jarg10, double jarg11) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  DayCounter *arg4 = 0 ;
  Period *arg5 = 0 ;
  Frequency arg6 ;
  bool arg7 ;
  std::vector< Date > *arg8 = 0 ;
  std::vector< Volatility > *arg9 = 0 ;
  Rate arg10 ;
  Rate arg11 ;
  InterpolatedYoYOptionletVolatilityCurve< Linear > *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (Frequency)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (std::vector< Date > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Volatility > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg10 = (Rate)jarg10; 
  arg11 = (Rate)jarg11; 
  {
    try {
      result = (InterpolatedYoYOptionletVolatilityCurve< Linear > *)new InterpolatedYoYOptionletVolatilityCurve< Linear >(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4,(Period const &)*arg5,arg6,arg7,(std::vector< Date > const &)*arg8,(std::vector< Volatility > 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 ? new ext::shared_ptr<  InterpolatedYoYOptionletVolatilityCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InterpolatedYoYInflationOptionletVolatilityCurve(void * jarg1) {
  InterpolatedYoYOptionletVolatilityCurve< Linear > *arg1 = (InterpolatedYoYOptionletVolatilityCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedYoYOptionletVolatilityCurve< Linear > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedYoYOptionletVolatilityCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedYoYOptionletVolatilityCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KInterpolatedYoYInflationOptionletVolatilitySurface__SWIG_0(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, void * jarg10) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  DayCounter *arg4 = 0 ;
  Period *arg5 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *arg6 = 0 ;
  ext::shared_ptr< PricingEngine > *arg7 = 0 ;
  ext::shared_ptr< YoYOptionletStripper > *arg8 = 0 ;
  Real arg9 ;
  Linear *arg10 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempnull6 ;
  ext::shared_ptr< PricingEngine > tempnull7 ;
  ext::shared_ptr< YoYOptionletStripper > tempnull8 ;
  KInterpolatedYoYOptionletVolatilitySurface< Linear > *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< YoYCapFloorTermPriceSurface > *)jarg6 : &tempnull6; 
  arg7 = jarg7 ? (ext::shared_ptr< PricingEngine > *)jarg7 : &tempnull7; 
  arg8 = jarg8 ? (ext::shared_ptr< YoYOptionletStripper > *)jarg8 : &tempnull8; 
  arg9 = (Real)jarg9; 
  arg10 = (Linear *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (KInterpolatedYoYOptionletVolatilitySurface< Linear > *)new_KInterpolatedYoYOptionletVolatilitySurface_Sl_Linear_Sg___SWIG_0(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4,(Period const &)*arg5,(ext::shared_ptr< YoYCapFloorTermPriceSurface > const &)*arg6,(ext::shared_ptr< PricingEngine > const &)*arg7,(ext::shared_ptr< YoYOptionletStripper > const &)*arg8,arg9,(Linear 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 = result ? new ext::shared_ptr<  KInterpolatedYoYOptionletVolatilitySurface<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KInterpolatedYoYInflationOptionletVolatilitySurface__SWIG_1(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  DayCounter *arg4 = 0 ;
  Period *arg5 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *arg6 = 0 ;
  ext::shared_ptr< PricingEngine > *arg7 = 0 ;
  ext::shared_ptr< YoYOptionletStripper > *arg8 = 0 ;
  Real arg9 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempnull6 ;
  ext::shared_ptr< PricingEngine > tempnull7 ;
  ext::shared_ptr< YoYOptionletStripper > tempnull8 ;
  KInterpolatedYoYOptionletVolatilitySurface< Linear > *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< YoYCapFloorTermPriceSurface > *)jarg6 : &tempnull6; 
  arg7 = jarg7 ? (ext::shared_ptr< PricingEngine > *)jarg7 : &tempnull7; 
  arg8 = jarg8 ? (ext::shared_ptr< YoYOptionletStripper > *)jarg8 : &tempnull8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (KInterpolatedYoYOptionletVolatilitySurface< Linear > *)new_KInterpolatedYoYOptionletVolatilitySurface_Sl_Linear_Sg___SWIG_0(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4,(Period const &)*arg5,(ext::shared_ptr< YoYCapFloorTermPriceSurface > const &)*arg6,(ext::shared_ptr< PricingEngine > const &)*arg7,(ext::shared_ptr< YoYOptionletStripper > 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 = result ? new ext::shared_ptr<  KInterpolatedYoYOptionletVolatilitySurface<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_KInterpolatedYoYInflationOptionletVolatilitySurface_Dslice(void * jarg1, void * jarg2) {
  void * jresult ;
  KInterpolatedYoYOptionletVolatilitySurface< Linear > *arg1 = (KInterpolatedYoYOptionletVolatilitySurface< Linear > *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< KInterpolatedYoYOptionletVolatilitySurface< Linear > const > *smartarg1 = 0 ;
  std::pair< std::vector< Rate >,std::vector< Volatility > > result;
  
  
  smartarg1 = (ext::shared_ptr< const KInterpolatedYoYOptionletVolatilitySurface<Linear> > *)jarg1;
  arg1 = (KInterpolatedYoYOptionletVolatilitySurface<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((KInterpolatedYoYOptionletVolatilitySurface< Linear > const *)arg1)->Dslice((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 std::pair< std::vector< Rate >,std::vector< Volatility > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_KInterpolatedYoYInflationOptionletVolatilitySurface(void * jarg1) {
  KInterpolatedYoYOptionletVolatilitySurface< Linear > *arg1 = (KInterpolatedYoYOptionletVolatilitySurface< Linear > *) 0 ;
  ext::shared_ptr< KInterpolatedYoYOptionletVolatilitySurface< Linear > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  KInterpolatedYoYOptionletVolatilitySurface<Linear> > *)jarg1;
  arg1 = (KInterpolatedYoYOptionletVolatilitySurface<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_ShortRateModel(void * jarg1) {
  ShortRateModel *arg1 = (ShortRateModel *) 0 ;
  ext::shared_ptr< ShortRateModel > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ShortRateModel > *)jarg1;
  arg1 = (ShortRateModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempnull1 ;
  Handle< ShortRateModel > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ShortRateModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Handle< ShortRateModel > *)new Handle< ShortRateModel >((ext::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 ;
  ext::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 = result ? new ext::shared_ptr< ShortRateModel >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ShortRateModelHandle_currentLink(void * jarg1) {
  void * jresult ;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  ext::shared_ptr< ShortRateModel > result;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< ShortRateModel >(result) : 0; 
  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 ;
  ext::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 = result ? new ext::shared_ptr< Observable >(result) : 0; 
  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(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< ext::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< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return ;
  } 
  arg7 = (std::vector< bool > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< ext::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< ext::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< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< ext::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< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< ext::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< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  {
    try {
      (*arg1)->calibrate((std::vector< ext::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_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 & 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_ShortRateModelHandle_value(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  Array *arg2 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg3 = 0 ;
  Real result;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(*arg1)->value((Array const &)*arg2,(std::vector< ext::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_ShortRateModelHandle_constraint(void * jarg1) {
  void * jresult ;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  ext::shared_ptr< Constraint > *result = 0 ;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  {
    try {
      result = (ext::shared_ptr< Constraint > *) &(*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 = *result ? new ext::shared_ptr< Constraint >(*result) : 0; 
  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_problemValues(void * jarg1) {
  void * jresult ;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  Array *result = 0 ;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  {
    try {
      result = (Array *) &(*arg1)->problemValues();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_ShortRateModelHandle_functionEvaluation(void * jarg1) {
  int jresult ;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  Integer result;
  
  arg1 = (Handle< ShortRateModel > *)jarg1; 
  {
    try {
      result = (Integer)(*arg1)->functionEvaluation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_RelinkableShortRateModelHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempnull1 ;
  RelinkableHandle< ShortRateModel > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ShortRateModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (RelinkableHandle< ShortRateModel > *)new RelinkableHandle< ShortRateModel >((ext::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 ;
  ext::shared_ptr< ShortRateModel > *arg2 = 0 ;
  ext::shared_ptr< ShortRateModel > tempnull2 ;
  
  arg1 = (RelinkableHandle< ShortRateModel > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< ShortRateModel > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->linkTo((ext::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_RelinkableShortRateModelHandle_reset(void * jarg1) {
  RelinkableHandle< ShortRateModel > *arg1 = (RelinkableHandle< ShortRateModel > *) 0 ;
  
  arg1 = (RelinkableHandle< ShortRateModel > *)jarg1; 
  {
    try {
      RelinkableHandle_Sl_ShortRateModel_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 double SWIGSTDCALL CSharp_QuantLib_OneFactorAffineModel_discountBond__SWIG_0(void * jarg1, double jarg2, double jarg3, void * jarg4) {
  double jresult ;
  OneFactorAffineModel *arg1 = (OneFactorAffineModel *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Array arg4 ;
  ext::shared_ptr< OneFactorAffineModel const > *smartarg1 = 0 ;
  Array *argp4 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OneFactorAffineModel > *)jarg1;
  arg1 = (OneFactorAffineModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  argp4 = (Array *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Array", 0);
    return 0;
  }
  arg4 = *argp4; 
  {
    try {
      result = (Real)((OneFactorAffineModel const *)arg1)->discountBond(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_OneFactorAffineModel_discountBond__SWIG_1(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  OneFactorAffineModel *arg1 = (OneFactorAffineModel *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  ext::shared_ptr< OneFactorAffineModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OneFactorAffineModel > *)jarg1;
  arg1 = (OneFactorAffineModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Real)((OneFactorAffineModel const *)arg1)->discountBond(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_OneFactorAffineModel_discount(void * jarg1, double jarg2) {
  double jresult ;
  OneFactorAffineModel *arg1 = (OneFactorAffineModel *) 0 ;
  Time arg2 ;
  ext::shared_ptr< OneFactorAffineModel const > *smartarg1 = 0 ;
  DiscountFactor result;
  
  
  smartarg1 = (ext::shared_ptr< const OneFactorAffineModel > *)jarg1;
  arg1 = (OneFactorAffineModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (DiscountFactor)((OneFactorAffineModel const *)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_delete_OneFactorAffineModel(void * jarg1) {
  OneFactorAffineModel *arg1 = (OneFactorAffineModel *) 0 ;
  ext::shared_ptr< OneFactorAffineModel > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OneFactorAffineModel > *)jarg1;
  arg1 = (OneFactorAffineModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Vasicek *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Vasicek *)new Vasicek(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 ? new ext::shared_ptr<  Vasicek >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Vasicek *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Vasicek *)new Vasicek(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 ? new ext::shared_ptr<  Vasicek >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Vasicek *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Vasicek *)new Vasicek(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 ? new ext::shared_ptr<  Vasicek >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Vasicek__SWIG_3(double jarg1, double jarg2) {
  void * jresult ;
  Rate arg1 ;
  Real arg2 ;
  Vasicek *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Vasicek *)new Vasicek(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 ? new ext::shared_ptr<  Vasicek >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Vasicek__SWIG_4(double jarg1) {
  void * jresult ;
  Rate arg1 ;
  Vasicek *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  {
    try {
      result = (Vasicek *)new Vasicek(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  Vasicek >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Vasicek(void * jarg1) {
  Vasicek *arg1 = (Vasicek *) 0 ;
  ext::shared_ptr< Vasicek > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Vasicek > *)jarg1;
  arg1 = (Vasicek *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  HullWhite *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (HullWhite *)new HullWhite((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 = result ? new ext::shared_ptr<  HullWhite >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HullWhite__SWIG_1(void * jarg1, double jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  HullWhite *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (HullWhite *)new HullWhite((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 = result ? new ext::shared_ptr<  HullWhite >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HullWhite__SWIG_2(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  HullWhite *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (HullWhite *)new HullWhite((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 = result ? new ext::shared_ptr<  HullWhite >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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)HullWhite::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_HullWhite_termStructure(void * jarg1) {
  void * jresult ;
  HullWhite *arg1 = (HullWhite *) 0 ;
  ext::shared_ptr< HullWhite const > *smartarg1 = 0 ;
  Handle< YieldTermStructure > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const HullWhite > *)jarg1;
  arg1 = (HullWhite *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Handle< YieldTermStructure > *) &((HullWhite const *)arg1)->termStructure();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HullWhite(void * jarg1) {
  HullWhite *arg1 = (HullWhite *) 0 ;
  ext::shared_ptr< HullWhite > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  HullWhite > *)jarg1;
  arg1 = (HullWhite *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  BlackKarasinski *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (BlackKarasinski *)new BlackKarasinski((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 = result ? new ext::shared_ptr<  BlackKarasinski >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackKarasinski__SWIG_1(void * jarg1, double jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  BlackKarasinski *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (BlackKarasinski *)new BlackKarasinski((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 = result ? new ext::shared_ptr<  BlackKarasinski >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackKarasinski__SWIG_2(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  BlackKarasinski *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackKarasinski *)new BlackKarasinski((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 = result ? new ext::shared_ptr<  BlackKarasinski >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackKarasinski_termStructure(void * jarg1) {
  void * jresult ;
  BlackKarasinski *arg1 = (BlackKarasinski *) 0 ;
  ext::shared_ptr< BlackKarasinski const > *smartarg1 = 0 ;
  Handle< YieldTermStructure > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const BlackKarasinski > *)jarg1;
  arg1 = (BlackKarasinski *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Handle< YieldTermStructure > *) &((BlackKarasinski const *)arg1)->termStructure();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(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) {
  BlackKarasinski *arg1 = (BlackKarasinski *) 0 ;
  ext::shared_ptr< BlackKarasinski > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackKarasinski > *)jarg1;
  arg1 = (BlackKarasinski *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CoxIngersollRoss__SWIG_0(double jarg1, double jarg2, double jarg3, double jarg4) {
  void * jresult ;
  Rate arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  CoxIngersollRoss *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (CoxIngersollRoss *)new CoxIngersollRoss(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 ? new ext::shared_ptr<  CoxIngersollRoss >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CoxIngersollRoss__SWIG_1(double jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Rate arg1 ;
  Real arg2 ;
  Real arg3 ;
  CoxIngersollRoss *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (CoxIngersollRoss *)new CoxIngersollRoss(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 ? new ext::shared_ptr<  CoxIngersollRoss >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CoxIngersollRoss__SWIG_2(double jarg1, double jarg2) {
  void * jresult ;
  Rate arg1 ;
  Real arg2 ;
  CoxIngersollRoss *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (CoxIngersollRoss *)new CoxIngersollRoss(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 ? new ext::shared_ptr<  CoxIngersollRoss >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CoxIngersollRoss__SWIG_3(double jarg1) {
  void * jresult ;
  Rate arg1 ;
  CoxIngersollRoss *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  {
    try {
      result = (CoxIngersollRoss *)new CoxIngersollRoss(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  CoxIngersollRoss >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CoxIngersollRoss_discount(void * jarg1, double jarg2) {
  double jresult ;
  CoxIngersollRoss *arg1 = (CoxIngersollRoss *) 0 ;
  Time arg2 ;
  ext::shared_ptr< CoxIngersollRoss const > *smartarg1 = 0 ;
  DiscountFactor result;
  
  
  smartarg1 = (ext::shared_ptr< const CoxIngersollRoss > *)jarg1;
  arg1 = (CoxIngersollRoss *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (DiscountFactor)((CoxIngersollRoss const *)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_delete_CoxIngersollRoss(void * jarg1) {
  CoxIngersollRoss *arg1 = (CoxIngersollRoss *) 0 ;
  ext::shared_ptr< CoxIngersollRoss > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CoxIngersollRoss > *)jarg1;
  arg1 = (CoxIngersollRoss *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExtendedCoxIngersollRoss__SWIG_0(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  ExtendedCoxIngersollRoss *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (ExtendedCoxIngersollRoss *)new ExtendedCoxIngersollRoss((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 = result ? new ext::shared_ptr<  ExtendedCoxIngersollRoss >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExtendedCoxIngersollRoss__SWIG_1(void * jarg1, double jarg2, double jarg3, double jarg4) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  ExtendedCoxIngersollRoss *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (ExtendedCoxIngersollRoss *)new ExtendedCoxIngersollRoss((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 = result ? new ext::shared_ptr<  ExtendedCoxIngersollRoss >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExtendedCoxIngersollRoss__SWIG_2(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  ExtendedCoxIngersollRoss *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (ExtendedCoxIngersollRoss *)new ExtendedCoxIngersollRoss((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 = result ? new ext::shared_ptr<  ExtendedCoxIngersollRoss >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExtendedCoxIngersollRoss__SWIG_3(void * jarg1, double jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  ExtendedCoxIngersollRoss *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (ExtendedCoxIngersollRoss *)new ExtendedCoxIngersollRoss((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 = result ? new ext::shared_ptr<  ExtendedCoxIngersollRoss >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExtendedCoxIngersollRoss__SWIG_4(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  ExtendedCoxIngersollRoss *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ExtendedCoxIngersollRoss *)new ExtendedCoxIngersollRoss((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 = result ? new ext::shared_ptr<  ExtendedCoxIngersollRoss >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ExtendedCoxIngersollRoss_discount(void * jarg1, double jarg2) {
  double jresult ;
  ExtendedCoxIngersollRoss *arg1 = (ExtendedCoxIngersollRoss *) 0 ;
  Time arg2 ;
  ext::shared_ptr< ExtendedCoxIngersollRoss const > *smartarg1 = 0 ;
  DiscountFactor result;
  
  
  smartarg1 = (ext::shared_ptr< const ExtendedCoxIngersollRoss > *)jarg1;
  arg1 = (ExtendedCoxIngersollRoss *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (DiscountFactor)((ExtendedCoxIngersollRoss const *)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_delete_ExtendedCoxIngersollRoss(void * jarg1) {
  ExtendedCoxIngersollRoss *arg1 = (ExtendedCoxIngersollRoss *) 0 ;
  ext::shared_ptr< ExtendedCoxIngersollRoss > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ExtendedCoxIngersollRoss > *)jarg1;
  arg1 = (ExtendedCoxIngersollRoss *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  G2 *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (G2 *)new G2((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 = result ? new ext::shared_ptr<  G2 >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  G2 *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (G2 *)new G2((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 = result ? new ext::shared_ptr<  G2 >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  G2 *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (G2 *)new G2((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 = result ? new ext::shared_ptr<  G2 >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  G2 *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (G2 *)new G2((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 = result ? new ext::shared_ptr<  G2 >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_G2__SWIG_4(void * jarg1, double jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  G2 *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (G2 *)new G2((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 = result ? new ext::shared_ptr<  G2 >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_G2__SWIG_5(void * jarg1) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  G2 *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (G2 *)new G2((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 = result ? new ext::shared_ptr<  G2 >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_G2_termStructure(void * jarg1) {
  void * jresult ;
  G2 *arg1 = (G2 *) 0 ;
  ext::shared_ptr< G2 const > *smartarg1 = 0 ;
  Handle< YieldTermStructure > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const G2 > *)jarg1;
  arg1 = (G2 *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Handle< YieldTermStructure > *) &((G2 const *)arg1)->termStructure();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_G2(void * jarg1) {
  G2 *arg1 = (G2 *) 0 ;
  ext::shared_ptr< G2 > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  G2 > *)jarg1;
  arg1 = (G2 *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< OneFactorAffineModel > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< OneFactorAffineModel > tempnull1 ;
  JamshidianSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OneFactorAffineModel > *)jarg1 : &tempnull1; 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (JamshidianSwaptionEngine *)new JamshidianSwaptionEngine((ext::shared_ptr< OneFactorAffineModel > 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 ? new ext::shared_ptr<  JamshidianSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_JamshidianSwaptionEngine__SWIG_1(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< OneFactorAffineModel > *arg1 = 0 ;
  ext::shared_ptr< OneFactorAffineModel > tempnull1 ;
  JamshidianSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OneFactorAffineModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (JamshidianSwaptionEngine *)new JamshidianSwaptionEngine((ext::shared_ptr< OneFactorAffineModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  JamshidianSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_JamshidianSwaptionEngine(void * jarg1) {
  JamshidianSwaptionEngine *arg1 = (JamshidianSwaptionEngine *) 0 ;
  ext::shared_ptr< JamshidianSwaptionEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  JamshidianSwaptionEngine > *)jarg1;
  arg1 = (JamshidianSwaptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< ShortRateModel > tempnull1 ;
  TreeSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ShortRateModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeSwaptionEngine *)new TreeSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  TreeSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeSwaptionEngine__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< ShortRateModel > tempnull1 ;
  TreeSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ShortRateModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (TreeSwaptionEngine *)new TreeSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  TreeSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeSwaptionEngine__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< ShortRateModel > tempnull1 ;
  TreeSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ShortRateModel > *)jarg1 : &tempnull1; 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeSwaptionEngine *)new TreeSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  TreeSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeSwaptionEngine__SWIG_3(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  ext::shared_ptr< ShortRateModel > tempnull1 ;
  TreeSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ShortRateModel > *)jarg1 : &tempnull1; 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeSwaptionEngine *)new TreeSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  TreeSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  TreeSwaptionEngine *result = 0 ;
  
  arg1 = (Handle< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ShortRateModel > const & is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeSwaptionEngine *)new TreeSwaptionEngine((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 = result ? new ext::shared_ptr<  TreeSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeSwaptionEngine__SWIG_5(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  Handle< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  TreeSwaptionEngine *result = 0 ;
  
  arg1 = (Handle< ShortRateModel > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< ShortRateModel > const & is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (TreeSwaptionEngine *)new TreeSwaptionEngine((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 = result ? new ext::shared_ptr<  TreeSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TreeSwaptionEngine(void * jarg1) {
  TreeSwaptionEngine *arg1 = (TreeSwaptionEngine *) 0 ;
  ext::shared_ptr< TreeSwaptionEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  TreeSwaptionEngine > *)jarg1;
  arg1 = (TreeSwaptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< OneFactorAffineModel > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< OneFactorAffineModel > tempnull1 ;
  AnalyticCapFloorEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OneFactorAffineModel > *)jarg1 : &tempnull1; 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AnalyticCapFloorEngine *)new AnalyticCapFloorEngine((ext::shared_ptr< OneFactorAffineModel > 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 ? new ext::shared_ptr<  AnalyticCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticCapFloorEngine__SWIG_1(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< OneFactorAffineModel > *arg1 = 0 ;
  ext::shared_ptr< OneFactorAffineModel > tempnull1 ;
  AnalyticCapFloorEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< OneFactorAffineModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticCapFloorEngine *)new AnalyticCapFloorEngine((ext::shared_ptr< OneFactorAffineModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticCapFloorEngine(void * jarg1) {
  AnalyticCapFloorEngine *arg1 = (AnalyticCapFloorEngine *) 0 ;
  ext::shared_ptr< AnalyticCapFloorEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticCapFloorEngine > *)jarg1;
  arg1 = (AnalyticCapFloorEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< ShortRateModel > tempnull1 ;
  TreeCapFloorEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ShortRateModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeCapFloorEngine *)new TreeCapFloorEngine((ext::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 = result ? new ext::shared_ptr<  TreeCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeCapFloorEngine__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< ShortRateModel > tempnull1 ;
  TreeCapFloorEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ShortRateModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (TreeCapFloorEngine *)new TreeCapFloorEngine((ext::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 = result ? new ext::shared_ptr<  TreeCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeCapFloorEngine__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< ShortRateModel > tempnull1 ;
  TreeCapFloorEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ShortRateModel > *)jarg1 : &tempnull1; 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeCapFloorEngine *)new TreeCapFloorEngine((ext::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 = result ? new ext::shared_ptr<  TreeCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeCapFloorEngine__SWIG_3(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  ext::shared_ptr< ShortRateModel > tempnull1 ;
  TreeCapFloorEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ShortRateModel > *)jarg1 : &tempnull1; 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeCapFloorEngine *)new TreeCapFloorEngine((ext::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 = result ? new ext::shared_ptr<  TreeCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TreeCapFloorEngine(void * jarg1) {
  TreeCapFloorEngine *arg1 = (TreeCapFloorEngine *) 0 ;
  ext::shared_ptr< TreeCapFloorEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  TreeCapFloorEngine > *)jarg1;
  arg1 = (TreeCapFloorEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  ext::shared_ptr< G2 > tempnull1 ;
  G2SwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< G2 > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (G2SwaptionEngine *)new G2SwaptionEngine((ext::shared_ptr< G2 > 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 ? new ext::shared_ptr<  G2SwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_G2SwaptionEngine(void * jarg1) {
  G2SwaptionEngine *arg1 = (G2SwaptionEngine *) 0 ;
  ext::shared_ptr< G2SwaptionEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  G2SwaptionEngine > *)jarg1;
  arg1 = (G2SwaptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Real arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< G2 > tempnull1 ;
  FdG2SwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< G2 > *)jarg1 : &tempnull1; 
  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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdG2SwaptionEngine *)new FdG2SwaptionEngine((ext::shared_ptr< G2 > 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 = result ? new ext::shared_ptr<  FdG2SwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Real arg6 ;
  ext::shared_ptr< G2 > tempnull1 ;
  FdG2SwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< G2 > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (FdG2SwaptionEngine *)new FdG2SwaptionEngine((ext::shared_ptr< G2 > 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 = result ? new ext::shared_ptr<  FdG2SwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< G2 > tempnull1 ;
  FdG2SwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< G2 > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdG2SwaptionEngine *)new FdG2SwaptionEngine((ext::shared_ptr< G2 > 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 ? new ext::shared_ptr<  FdG2SwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdG2SwaptionEngine__SWIG_3(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< G2 > tempnull1 ;
  FdG2SwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< G2 > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdG2SwaptionEngine *)new FdG2SwaptionEngine((ext::shared_ptr< G2 > 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 ? new ext::shared_ptr<  FdG2SwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdG2SwaptionEngine__SWIG_4(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< G2 > tempnull1 ;
  FdG2SwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< G2 > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdG2SwaptionEngine *)new FdG2SwaptionEngine((ext::shared_ptr< G2 > 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 ? new ext::shared_ptr<  FdG2SwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdG2SwaptionEngine__SWIG_5(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< G2 > tempnull1 ;
  FdG2SwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< G2 > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdG2SwaptionEngine *)new FdG2SwaptionEngine((ext::shared_ptr< G2 > 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 ? new ext::shared_ptr<  FdG2SwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdG2SwaptionEngine__SWIG_6(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  ext::shared_ptr< G2 > tempnull1 ;
  FdG2SwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< G2 > *)jarg1 : &tempnull1; 
  {
    try {
      result = (FdG2SwaptionEngine *)new FdG2SwaptionEngine((ext::shared_ptr< G2 > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdG2SwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdG2SwaptionEngine(void * jarg1) {
  FdG2SwaptionEngine *arg1 = (FdG2SwaptionEngine *) 0 ;
  ext::shared_ptr< FdG2SwaptionEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdG2SwaptionEngine > *)jarg1;
  arg1 = (FdG2SwaptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Real arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< HullWhite > tempnull1 ;
  FdHullWhiteSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HullWhite > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (FdmSchemeDesc *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdHullWhiteSwaptionEngine *)new FdHullWhiteSwaptionEngine((ext::shared_ptr< HullWhite > 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 = result ? new ext::shared_ptr<  FdHullWhiteSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Real arg5 ;
  ext::shared_ptr< HullWhite > tempnull1 ;
  FdHullWhiteSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HullWhite > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (FdHullWhiteSwaptionEngine *)new FdHullWhiteSwaptionEngine((ext::shared_ptr< HullWhite > 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 ? new ext::shared_ptr<  FdHullWhiteSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHullWhiteSwaptionEngine__SWIG_2(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< HullWhite > tempnull1 ;
  FdHullWhiteSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HullWhite > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdHullWhiteSwaptionEngine *)new FdHullWhiteSwaptionEngine((ext::shared_ptr< HullWhite > 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 ? new ext::shared_ptr<  FdHullWhiteSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHullWhiteSwaptionEngine__SWIG_3(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< HullWhite > tempnull1 ;
  FdHullWhiteSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HullWhite > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdHullWhiteSwaptionEngine *)new FdHullWhiteSwaptionEngine((ext::shared_ptr< HullWhite > 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 ? new ext::shared_ptr<  FdHullWhiteSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHullWhiteSwaptionEngine__SWIG_4(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< HullWhite > tempnull1 ;
  FdHullWhiteSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HullWhite > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdHullWhiteSwaptionEngine *)new FdHullWhiteSwaptionEngine((ext::shared_ptr< HullWhite > 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 ? new ext::shared_ptr<  FdHullWhiteSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdHullWhiteSwaptionEngine__SWIG_5(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > tempnull1 ;
  FdHullWhiteSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HullWhite > *)jarg1 : &tempnull1; 
  {
    try {
      result = (FdHullWhiteSwaptionEngine *)new FdHullWhiteSwaptionEngine((ext::shared_ptr< HullWhite > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdHullWhiteSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdHullWhiteSwaptionEngine(void * jarg1) {
  FdHullWhiteSwaptionEngine *arg1 = (FdHullWhiteSwaptionEngine *) 0 ;
  ext::shared_ptr< FdHullWhiteSwaptionEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdHullWhiteSwaptionEngine > *)jarg1;
  arg1 = (FdHullWhiteSwaptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticBSMHullWhiteEngine(double jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  ext::shared_ptr< HullWhite > *arg3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  ext::shared_ptr< HullWhite > tempnull3 ;
  AnalyticBSMHullWhiteEngine *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< HullWhite > *)jarg3 : &tempnull3; 
  {
    try {
      result = (AnalyticBSMHullWhiteEngine *)new AnalyticBSMHullWhiteEngine(arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,(ext::shared_ptr< HullWhite > 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 ? new ext::shared_ptr<  AnalyticBSMHullWhiteEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticBSMHullWhiteEngine(void * jarg1) {
  AnalyticBSMHullWhiteEngine *arg1 = (AnalyticBSMHullWhiteEngine *) 0 ;
  ext::shared_ptr< AnalyticBSMHullWhiteEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticBSMHullWhiteEngine > *)jarg1;
  arg1 = (AnalyticBSMHullWhiteEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BondPrice(double jarg1, int jarg2) {
  void * jresult ;
  Real arg1 ;
  BondPrice::Type arg2 ;
  BondPrice *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (BondPrice::Type)jarg2; 
  {
    try {
      result = (BondPrice *)new BondPrice(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_BondPrice_amount(void * jarg1) {
  double jresult ;
  BondPrice *arg1 = (BondPrice *) 0 ;
  Real result;
  
  arg1 = (BondPrice *)jarg1; 
  {
    try {
      result = (Real)((BondPrice 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_BondPrice_type(void * jarg1) {
  int jresult ;
  BondPrice *arg1 = (BondPrice *) 0 ;
  BondPrice::Type result;
  
  arg1 = (BondPrice *)jarg1; 
  {
    try {
      result = (BondPrice::Type)((BondPrice 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_BondPrice(void * jarg1) {
  BondPrice *arg1 = (BondPrice *) 0 ;
  
  arg1 = (BondPrice *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  Bond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Leg *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bond *)new Bond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Leg 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 ? new ext::shared_ptr<  Bond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Bond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bond *)new Bond(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 = result ? new ext::shared_ptr<  Bond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Bond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bond *)new Bond(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 = result ? new ext::shared_ptr<  Bond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bond__SWIG_3(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Date *arg3 = 0 ;
  Leg *arg4 = 0 ;
  Bond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Leg *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Leg const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bond *)new Bond(arg1,(Calendar const &)*arg2,(Date const &)*arg3,(Leg 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 ? new ext::shared_ptr<  Bond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bond__SWIG_4(unsigned int jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Date *arg3 = 0 ;
  Bond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bond *)new Bond(arg1,(Calendar 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 ? new ext::shared_ptr<  Bond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Bond__SWIG_5(unsigned int jarg1, void * jarg2) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Bond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Bond *)new Bond(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 = result ? new ext::shared_ptr<  Bond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_nextCouponRate__SWIG_0(void * jarg1, void * jarg2) {
  double jresult ;
  Bond *arg1 = (Bond *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)(arg1)->nextCouponRate((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 ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)(arg1)->nextCouponRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = (Bond *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)(arg1)->previousCouponRate((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 ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)(arg1)->previousCouponRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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 ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  Natural result;
  
  
  smartarg1 = (ext::shared_ptr< const Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Natural)((Bond const *)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 void * SWIGSTDCALL CSharp_QuantLib_Bond_settlementDate__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Bond *arg1 = (Bond *) 0 ;
  Date arg2 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Date *argp2 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (arg1)->settlementDate(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_settlementDate__SWIG_1(void * jarg1) {
  void * jresult ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->settlementDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_startDate(void * jarg1) {
  void * jresult ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Bond const *)arg1)->startDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_maturityDate(void * jarg1) {
  void * jresult ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Bond const *)arg1)->maturityDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_issueDate(void * jarg1) {
  void * jresult ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Bond const *)arg1)->issueDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_cashflows(void * jarg1) {
  void * jresult ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > > result;
  
  
  smartarg1 = (ext::shared_ptr< const Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Bond const *)arg1)->cashflows();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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< ext::shared_ptr< CashFlow > >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_redemptions(void * jarg1) {
  void * jresult ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > > result;
  
  
  smartarg1 = (ext::shared_ptr< const Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Bond const *)arg1)->redemptions();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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< ext::shared_ptr< CashFlow > >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_redemption(void * jarg1) {
  void * jresult ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  ext::shared_ptr< CashFlow > result;
  
  
  smartarg1 = (ext::shared_ptr< const Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Bond const *)arg1)->redemption();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< CashFlow >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_calendar(void * jarg1) {
  void * jresult ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  SwigValueWrapper< Calendar > result;
  
  
  smartarg1 = (ext::shared_ptr< const Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Bond const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Bond_notionals(void * jarg1) {
  void * jresult ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  std::vector< Real > result;
  
  
  smartarg1 = (ext::shared_ptr< const Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Bond const *)arg1)->notionals();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Bond_notional__SWIG_0(void * jarg1, void * jarg2) {
  double jresult ;
  Bond *arg1 = (Bond *) 0 ;
  Date arg2 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  Date *argp2 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = (Date *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (Real)((Bond const *)arg1)->notional(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((Bond const *)arg1)->notional();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->cleanPrice();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = (Bond *) 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(arg1)->cleanPrice(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 ;
  Bond *arg1 = (Bond *) 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Real)(arg1)->cleanPrice(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 ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->dirtyPrice();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = (Bond *) 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(arg1)->dirtyPrice(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 ;
  Bond *arg1 = (Bond *) 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Real)(arg1)->dirtyPrice(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 ;
  Bond *arg1 = (Bond *) 0 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Real arg5 ;
  Size arg6 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (Real)(arg1)->yield((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 ;
  Bond *arg1 = (Bond *) 0 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Real arg5 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)(arg1)->yield((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 ;
  Bond *arg1 = (Bond *) 0 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (DayCounter *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg3 = (Compounding)jarg3; 
  arg4 = (Frequency)jarg4; 
  {
    try {
      result = (Real)(arg1)->yield((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 ;
  Bond *arg1 = (Bond *) 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date *arg6 = 0 ;
  Real arg7 ;
  Size arg8 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  arg8 = (Size)jarg8; 
  {
    try {
      result = (Real)(arg1)->yield(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 ;
  Bond *arg1 = (Bond *) 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date *arg6 = 0 ;
  Real arg7 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (Real)(arg1)->yield(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 ;
  Bond *arg1 = (Bond *) 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Date *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(arg1)->yield(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 ;
  Bond *arg1 = (Bond *) 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Real)(arg1)->yield(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 ;
  Bond *arg1 = (Bond *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(arg1)->accruedAmount((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 ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->accruedAmount();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((Bond const *)arg1)->settlementValue();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = (Bond *) 0 ;
  Real arg2 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((Bond const *)arg1)->settlementValue(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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) {
  Bond *arg1 = (Bond *) 0 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Bond > *)jarg1;
  arg1 = (Bond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_simplifyNotificationGraph__SWIG_2(void * jarg1, unsigned int jarg2) {
  Bond *arg1 = 0 ;
  bool arg2 ;
  
  
  arg1 = (Bond *)(((ext::shared_ptr<  Bond > *)jarg1) ? ((ext::shared_ptr<  Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond & reference is null", 0);
    return ;
  } 
  arg2 = jarg2 ? true : false; 
  {
    try {
      simplifyNotificationGraph(*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_simplifyNotificationGraph__SWIG_3(void * jarg1) {
  Bond *arg1 = 0 ;
  
  
  arg1 = (Bond *)(((ext::shared_ptr<  Bond > *)jarg1) ? ((ext::shared_ptr<  Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond & reference is null", 0);
    return ;
  } 
  {
    try {
      simplifyNotificationGraph(*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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 ;
  Bond *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Spread arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date *arg7 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Spread)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)cleanPriceFromZSpread((Bond const &)*arg1,(ext::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 ;
  Bond *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Spread arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Spread)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Real)cleanPriceFromZSpread((Bond const &)*arg1,(ext::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_sinkingSchedule(void * jarg1, void * jarg2, int jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  Period *arg2 = 0 ;
  Frequency *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Frequency temp3 ;
  Schedule result;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  temp3 = (Frequency)jarg3; 
  arg3 = &temp3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = QuantLib::sinkingSchedule((Date const &)*arg1,(Period const &)*arg2,(enum Frequency 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 = new Schedule(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_sinkingNotionals(void * jarg1, int jarg2, double jarg3, double jarg4) {
  void * jresult ;
  Period *arg1 = 0 ;
  Frequency *arg2 = 0 ;
  Rate arg3 ;
  Real arg4 ;
  Frequency temp2 ;
  std::vector< Real > result;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  temp2 = (Frequency)jarg2; 
  arg2 = &temp2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = QuantLib::sinkingNotionals((Period const &)*arg1,(enum Frequency 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 std::vector< Real >(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 ;
  ZeroCouponBond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroCouponBond *)new ZeroCouponBond(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 = result ? new ext::shared_ptr<  ZeroCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ZeroCouponBond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (ZeroCouponBond *)new ZeroCouponBond(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 = result ? new ext::shared_ptr<  ZeroCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ZeroCouponBond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  {
    try {
      result = (ZeroCouponBond *)new ZeroCouponBond(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 = result ? new ext::shared_ptr<  ZeroCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ZeroCouponBond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ZeroCouponBond *)new ZeroCouponBond(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 = result ? new ext::shared_ptr<  ZeroCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroCouponBond(void * jarg1) {
  ZeroCouponBond *arg1 = (ZeroCouponBond *) 0 ;
  ext::shared_ptr< ZeroCouponBond > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ZeroCouponBond > *)jarg1;
  arg1 = (ZeroCouponBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  FixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg12 = (BusinessDayConvention)jarg12; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg12 = (BusinessDayConvention)jarg12; 
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_FixedRateBond_frequency(void * jarg1) {
  int jresult ;
  FixedRateBond *arg1 = (FixedRateBond *) 0 ;
  ext::shared_ptr< FixedRateBond const > *smartarg1 = 0 ;
  Frequency result;
  
  
  smartarg1 = (ext::shared_ptr< const FixedRateBond > *)jarg1;
  arg1 = (FixedRateBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Frequency)((FixedRateBond 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_FixedRateBond_dayCounter(void * jarg1) {
  void * jresult ;
  FixedRateBond *arg1 = (FixedRateBond *) 0 ;
  ext::shared_ptr< FixedRateBond const > *smartarg1 = 0 ;
  SwigValueWrapper< DayCounter > result;
  
  
  smartarg1 = (ext::shared_ptr< const FixedRateBond > *)jarg1;
  arg1 = (FixedRateBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((FixedRateBond 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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FixedRateBond(void * jarg1) {
  FixedRateBond *arg1 = (FixedRateBond *) 0 ;
  ext::shared_ptr< FixedRateBond > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FixedRateBond > *)jarg1;
  arg1 = (FixedRateBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFixedRateBond__SWIG_0(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, void * jarg8, void * jarg9, int jarg10, unsigned int jarg11, void * jarg12, int jarg13) {
  void * jresult ;
  Integer arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Date arg7 ;
  Period *arg8 = 0 ;
  Calendar *arg9 = 0 ;
  BusinessDayConvention arg10 ;
  bool arg11 ;
  std::vector< Real > *arg12 = 0 ;
  Integer arg13 ;
  Date *argp7 ;
  AmortizingFixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg9 = (Calendar *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg10 = (BusinessDayConvention)jarg10; 
  arg11 = jarg11 ? true : false; 
  arg12 = (std::vector< Real > *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg13 = (Integer)jarg13; 
  {
    try {
      result = (AmortizingFixedRateBond *)new AmortizingFixedRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(std::vector< Rate > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(Period const &)*arg8,(Calendar const &)*arg9,arg10,arg11,(std::vector< Real > 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 = result ? new ext::shared_ptr<  AmortizingFixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFixedRateBond__SWIG_1(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, void * jarg8, void * jarg9, int jarg10, unsigned int jarg11, void * jarg12) {
  void * jresult ;
  Integer arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Date arg7 ;
  Period *arg8 = 0 ;
  Calendar *arg9 = 0 ;
  BusinessDayConvention arg10 ;
  bool arg11 ;
  std::vector< Real > *arg12 = 0 ;
  Date *argp7 ;
  AmortizingFixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg9 = (Calendar *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg10 = (BusinessDayConvention)jarg10; 
  arg11 = jarg11 ? true : false; 
  arg12 = (std::vector< Real > *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingFixedRateBond *)new AmortizingFixedRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(std::vector< Rate > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(Period const &)*arg8,(Calendar const &)*arg9,arg10,arg11,(std::vector< Real > 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 = result ? new ext::shared_ptr<  AmortizingFixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFixedRateBond__SWIG_2(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, void * jarg8, void * jarg9, int jarg10, unsigned int jarg11) {
  void * jresult ;
  Integer arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Date arg7 ;
  Period *arg8 = 0 ;
  Calendar *arg9 = 0 ;
  BusinessDayConvention arg10 ;
  bool arg11 ;
  Date *argp7 ;
  AmortizingFixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg9 = (Calendar *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg10 = (BusinessDayConvention)jarg10; 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (AmortizingFixedRateBond *)new AmortizingFixedRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(std::vector< Rate > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(Period const &)*arg8,(Calendar 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 ? new ext::shared_ptr<  AmortizingFixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFixedRateBond__SWIG_3(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, void * jarg8, void * jarg9, int jarg10) {
  void * jresult ;
  Integer arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Date arg7 ;
  Period *arg8 = 0 ;
  Calendar *arg9 = 0 ;
  BusinessDayConvention arg10 ;
  Date *argp7 ;
  AmortizingFixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg9 = (Calendar *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg10 = (BusinessDayConvention)jarg10; 
  {
    try {
      result = (AmortizingFixedRateBond *)new AmortizingFixedRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(std::vector< Rate > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(Period const &)*arg8,(Calendar 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 ? new ext::shared_ptr<  AmortizingFixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFixedRateBond__SWIG_4(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Integer arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Date arg7 ;
  Period *arg8 = 0 ;
  Calendar *arg9 = 0 ;
  Date *argp7 ;
  AmortizingFixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg9 = (Calendar *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingFixedRateBond *)new AmortizingFixedRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(std::vector< Rate > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(Period const &)*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 = result ? new ext::shared_ptr<  AmortizingFixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFixedRateBond__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Date arg7 ;
  Period *arg8 = 0 ;
  Date *argp7 ;
  AmortizingFixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Period *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingFixedRateBond *)new AmortizingFixedRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(std::vector< Rate > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(Period 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 ? new ext::shared_ptr<  AmortizingFixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFixedRateBond__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7) {
  void * jresult ;
  Integer arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Date arg7 ;
  Date *argp7 ;
  AmortizingFixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  argp7 = (Date *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (AmortizingFixedRateBond *)new AmortizingFixedRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  AmortizingFixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFixedRateBond__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Integer arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  AmortizingFixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  {
    try {
      result = (AmortizingFixedRateBond *)new AmortizingFixedRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  AmortizingFixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFixedRateBond__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  AmortizingFixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingFixedRateBond *)new AmortizingFixedRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  AmortizingFixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_AmortizingFixedRateBond_frequency(void * jarg1) {
  int jresult ;
  AmortizingFixedRateBond *arg1 = (AmortizingFixedRateBond *) 0 ;
  ext::shared_ptr< AmortizingFixedRateBond const > *smartarg1 = 0 ;
  Frequency result;
  
  
  smartarg1 = (ext::shared_ptr< const AmortizingFixedRateBond > *)jarg1;
  arg1 = (AmortizingFixedRateBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Frequency)((AmortizingFixedRateBond 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_AmortizingFixedRateBond_dayCounter(void * jarg1) {
  void * jresult ;
  AmortizingFixedRateBond *arg1 = (AmortizingFixedRateBond *) 0 ;
  ext::shared_ptr< AmortizingFixedRateBond const > *smartarg1 = 0 ;
  SwigValueWrapper< DayCounter > result;
  
  
  smartarg1 = (ext::shared_ptr< const AmortizingFixedRateBond > *)jarg1;
  arg1 = (AmortizingFixedRateBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((AmortizingFixedRateBond 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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AmortizingFixedRateBond(void * jarg1) {
  AmortizingFixedRateBond *arg1 = (AmortizingFixedRateBond *) 0 ;
  ext::shared_ptr< AmortizingFixedRateBond > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AmortizingFixedRateBond > *)jarg1;
  arg1 = (AmortizingFixedRateBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFloatingRateBond__SWIG_0(unsigned long jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, void * jarg13, void * jarg14, void * jarg15, int jarg16, unsigned int jarg17, void * jarg18, int jarg19) {
  void * jresult ;
  Size arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Date *arg13 = 0 ;
  Period *arg14 = 0 ;
  Calendar *arg15 = 0 ;
  BusinessDayConvention arg16 ;
  bool arg17 ;
  std::vector< Real > *arg18 = 0 ;
  Integer arg19 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AmortizingFloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (Period *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg15 = (Calendar *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg16 = (BusinessDayConvention)jarg16; 
  arg17 = jarg17 ? true : false; 
  arg18 = (std::vector< Real > *)jarg18;
  if (!arg18) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg19 = (Integer)jarg19; 
  {
    try {
      result = (AmortizingFloatingRateBond *)new AmortizingFloatingRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > const &)*arg11,arg12,(Date const &)*arg13,(Period const &)*arg14,(Calendar const &)*arg15,arg16,arg17,(std::vector< Real > const &)*arg18,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 = result ? new ext::shared_ptr<  AmortizingFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFloatingRateBond__SWIG_1(unsigned long jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, void * jarg13, void * jarg14, void * jarg15, int jarg16, unsigned int jarg17, void * jarg18) {
  void * jresult ;
  Size arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Date *arg13 = 0 ;
  Period *arg14 = 0 ;
  Calendar *arg15 = 0 ;
  BusinessDayConvention arg16 ;
  bool arg17 ;
  std::vector< Real > *arg18 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AmortizingFloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (Period *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg15 = (Calendar *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg16 = (BusinessDayConvention)jarg16; 
  arg17 = jarg17 ? true : false; 
  arg18 = (std::vector< Real > *)jarg18;
  if (!arg18) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingFloatingRateBond *)new AmortizingFloatingRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > const &)*arg11,arg12,(Date const &)*arg13,(Period const &)*arg14,(Calendar const &)*arg15,arg16,arg17,(std::vector< Real > 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 = result ? new ext::shared_ptr<  AmortizingFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFloatingRateBond__SWIG_2(unsigned long jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, void * jarg13, void * jarg14, void * jarg15, int jarg16, unsigned int jarg17) {
  void * jresult ;
  Size arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Date *arg13 = 0 ;
  Period *arg14 = 0 ;
  Calendar *arg15 = 0 ;
  BusinessDayConvention arg16 ;
  bool arg17 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AmortizingFloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (Period *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg15 = (Calendar *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg16 = (BusinessDayConvention)jarg16; 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = (AmortizingFloatingRateBond *)new AmortizingFloatingRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > const &)*arg11,arg12,(Date 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 = result ? new ext::shared_ptr<  AmortizingFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFloatingRateBond__SWIG_3(unsigned long jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, void * jarg13, void * jarg14, void * jarg15, int jarg16) {
  void * jresult ;
  Size arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Date *arg13 = 0 ;
  Period *arg14 = 0 ;
  Calendar *arg15 = 0 ;
  BusinessDayConvention arg16 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AmortizingFloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (Period *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg15 = (Calendar *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg16 = (BusinessDayConvention)jarg16; 
  {
    try {
      result = (AmortizingFloatingRateBond *)new AmortizingFloatingRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > const &)*arg11,arg12,(Date 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 = result ? new ext::shared_ptr<  AmortizingFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFloatingRateBond__SWIG_4(unsigned long jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, void * jarg13, void * jarg14, void * jarg15) {
  void * jresult ;
  Size arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Date *arg13 = 0 ;
  Period *arg14 = 0 ;
  Calendar *arg15 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AmortizingFloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (Period *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg15 = (Calendar *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingFloatingRateBond *)new AmortizingFloatingRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > const &)*arg11,arg12,(Date 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 = result ? new ext::shared_ptr<  AmortizingFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFloatingRateBond__SWIG_5(unsigned long jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, void * jarg13, void * jarg14) {
  void * jresult ;
  Size arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Date *arg13 = 0 ;
  Period *arg14 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AmortizingFloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (Period *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingFloatingRateBond *)new AmortizingFloatingRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > const &)*arg11,arg12,(Date 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 = result ? new ext::shared_ptr<  AmortizingFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFloatingRateBond__SWIG_6(unsigned long jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, void * jarg13) {
  void * jresult ;
  Size arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Date *arg13 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AmortizingFloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingFloatingRateBond *)new AmortizingFloatingRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > const &)*arg11,arg12,(Date 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 = result ? new ext::shared_ptr<  AmortizingFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFloatingRateBond__SWIG_7(unsigned long jarg1, void * 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 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AmortizingFloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (AmortizingFloatingRateBond *)new AmortizingFloatingRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  AmortizingFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFloatingRateBond__SWIG_8(unsigned long jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Size arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AmortizingFloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingFloatingRateBond *)new AmortizingFloatingRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  AmortizingFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFloatingRateBond__SWIG_9(unsigned long jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Size arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Size arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AmortizingFloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingFloatingRateBond *)new AmortizingFloatingRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  AmortizingFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFloatingRateBond__SWIG_10(unsigned long jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Size arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Size arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AmortizingFloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingFloatingRateBond *)new AmortizingFloatingRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > 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 ? new ext::shared_ptr<  AmortizingFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFloatingRateBond__SWIG_11(unsigned long jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7, void * jarg8) {
  void * jresult ;
  Size arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Size arg7 ;
  std::vector< Real > *arg8 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AmortizingFloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingFloatingRateBond *)new AmortizingFloatingRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > 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 ? new ext::shared_ptr<  AmortizingFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFloatingRateBond__SWIG_12(unsigned long jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned long jarg7) {
  void * jresult ;
  Size arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Size arg7 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AmortizingFloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (AmortizingFloatingRateBond *)new AmortizingFloatingRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  AmortizingFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFloatingRateBond__SWIG_13(unsigned long jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Size arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AmortizingFloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  {
    try {
      result = (AmortizingFloatingRateBond *)new AmortizingFloatingRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  AmortizingFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingFloatingRateBond__SWIG_14(unsigned long jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Size arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  AmortizingFloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingFloatingRateBond *)new AmortizingFloatingRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  AmortizingFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AmortizingFloatingRateBond(void * jarg1) {
  AmortizingFloatingRateBond *arg1 = (AmortizingFloatingRateBond *) 0 ;
  ext::shared_ptr< AmortizingFloatingRateBond > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AmortizingFloatingRateBond > *)jarg1;
  arg1 = (AmortizingFloatingRateBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 * jarg15, void * jarg16, int jarg17, unsigned int jarg18) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Period *arg15 = 0 ;
  Calendar *arg16 = 0 ;
  BusinessDayConvention arg17 ;
  bool arg18 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Real)jarg13; 
  arg14 = (Date *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg15 = (Period *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg16 = (Calendar *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg17 = (BusinessDayConvention)jarg17; 
  arg18 = jarg18 ? true : false; 
  {
    try {
      result = (FloatingRateBond *)new FloatingRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > const &)*arg11,arg12,arg13,(Date const &)*arg14,(Period const &)*arg15,(Calendar const &)*arg16,arg17,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 = result ? new ext::shared_ptr<  FloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg14, void * jarg15, void * jarg16, int jarg17) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Period *arg15 = 0 ;
  Calendar *arg16 = 0 ;
  BusinessDayConvention arg17 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Real)jarg13; 
  arg14 = (Date *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg15 = (Period *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg16 = (Calendar *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg17 = (BusinessDayConvention)jarg17; 
  {
    try {
      result = (FloatingRateBond *)new FloatingRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > const &)*arg11,arg12,arg13,(Date const &)*arg14,(Period const &)*arg15,(Calendar const &)*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 = result ? new ext::shared_ptr<  FloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, double jarg13, void * jarg14, void * jarg15, void * jarg16) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Period *arg15 = 0 ;
  Calendar *arg16 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Real)jarg13; 
  arg14 = (Date *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg15 = (Period *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg16 = (Calendar *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatingRateBond *)new FloatingRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > const &)*arg11,arg12,arg13,(Date const &)*arg14,(Period const &)*arg15,(Calendar 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 = result ? new ext::shared_ptr<  FloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, unsigned int jarg12, double jarg13, void * jarg14, void * jarg15) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  Period *arg15 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Real)jarg13; 
  arg14 = (Date *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg15 = (Period *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatingRateBond *)new FloatingRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > const &)*arg11,arg12,arg13,(Date const &)*arg14,(Period 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 = result ? new ext::shared_ptr<  FloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg11, unsigned int jarg12, double jarg13, void * jarg14) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Real)jarg13; 
  arg14 = (Date *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatingRateBond *)new FloatingRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg10, void * jarg11, unsigned int jarg12, double jarg13) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Real)jarg13; 
  {
    try {
      result = (FloatingRateBond *)new FloatingRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg9, void * jarg10, void * jarg11, unsigned int jarg12) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (FloatingRateBond *)new FloatingRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *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 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatingRateBond *)new FloatingRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateBond__SWIG_8(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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Size arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatingRateBond *)new FloatingRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateBond__SWIG_9(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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Size arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatingRateBond *)new FloatingRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > 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 ? new ext::shared_ptr<  FloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateBond__SWIG_10(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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Size arg7 ;
  std::vector< Real > *arg8 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatingRateBond *)new FloatingRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > 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 ? new ext::shared_ptr<  FloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateBond__SWIG_11(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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Size arg7 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (FloatingRateBond *)new FloatingRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  FloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateBond__SWIG_12(unsigned long jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  {
    try {
      result = (FloatingRateBond *)new FloatingRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  FloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatingRateBond__SWIG_13(unsigned long jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FloatingRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FloatingRateBond *)new FloatingRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  FloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FloatingRateBond(void * jarg1) {
  FloatingRateBond *arg1 = (FloatingRateBond *) 0 ;
  ext::shared_ptr< FloatingRateBond > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FloatingRateBond > *)jarg1;
  arg1 = (FloatingRateBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< SwapIndex > *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 ;
  ext::shared_ptr< SwapIndex > tempnull4 ;
  CmsRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< SwapIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Real)jarg13; 
  arg14 = (Date *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsRateBond *)new CmsRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< SwapIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CmsRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< SwapIndex > *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 ;
  ext::shared_ptr< SwapIndex > tempnull4 ;
  CmsRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< SwapIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Real)jarg13; 
  {
    try {
      result = (CmsRateBond *)new CmsRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< SwapIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CmsRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< SwapIndex > *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 ;
  ext::shared_ptr< SwapIndex > tempnull4 ;
  CmsRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< SwapIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (CmsRateBond *)new CmsRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< SwapIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CmsRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< SwapIndex > *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 ;
  ext::shared_ptr< SwapIndex > tempnull4 ;
  CmsRateBond *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< SwapIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CmsRateBond *)new CmsRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< SwapIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CmsRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CmsRateBond(void * jarg1) {
  CmsRateBond *arg1 = (CmsRateBond *) 0 ;
  ext::shared_ptr< CmsRateBond > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CmsRateBond > *)jarg1;
  arg1 = (CmsRateBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingCmsRateBond__SWIG_0(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, void * jarg13) {
  void * jresult ;
  Natural arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > *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 ;
  Date *arg13 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull4 ;
  AmortizingCmsRateBond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< SwapIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingCmsRateBond *)new AmortizingCmsRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< SwapIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > const &)*arg11,arg12,(Date 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 = result ? new ext::shared_ptr<  AmortizingCmsRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingCmsRateBond__SWIG_1(unsigned int jarg1, void * 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 ;
  Natural arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > *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 ;
  ext::shared_ptr< SwapIndex > tempnull4 ;
  AmortizingCmsRateBond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< SwapIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (AmortizingCmsRateBond *)new AmortizingCmsRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< SwapIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  AmortizingCmsRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingCmsRateBond__SWIG_2(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Natural arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > *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 ;
  ext::shared_ptr< SwapIndex > tempnull4 ;
  AmortizingCmsRateBond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< SwapIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg11 = (std::vector< Rate > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingCmsRateBond *)new AmortizingCmsRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< SwapIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > const &)*arg10,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  AmortizingCmsRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingCmsRateBond__SWIG_3(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Natural arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Natural arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  std::vector< Rate > *arg10 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull4 ;
  AmortizingCmsRateBond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< SwapIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Rate > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingCmsRateBond *)new AmortizingCmsRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< SwapIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > const &)*arg9,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  AmortizingCmsRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingCmsRateBond__SWIG_4(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Natural arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Natural arg7 ;
  std::vector< Real > *arg8 = 0 ;
  std::vector< Spread > *arg9 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull4 ;
  AmortizingCmsRateBond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< SwapIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Spread > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingCmsRateBond *)new AmortizingCmsRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< SwapIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > const &)*arg8,(std::vector< Spread > 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 ? new ext::shared_ptr<  AmortizingCmsRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingCmsRateBond__SWIG_5(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8) {
  void * jresult ;
  Natural arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Natural arg7 ;
  std::vector< Real > *arg8 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull4 ;
  AmortizingCmsRateBond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< SwapIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingCmsRateBond *)new AmortizingCmsRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< SwapIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real > 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 ? new ext::shared_ptr<  AmortizingCmsRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingCmsRateBond__SWIG_6(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, unsigned int jarg7) {
  void * jresult ;
  Natural arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Natural arg7 ;
  ext::shared_ptr< SwapIndex > tempnull4 ;
  AmortizingCmsRateBond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< SwapIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Natural)jarg7; 
  {
    try {
      result = (AmortizingCmsRateBond *)new AmortizingCmsRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  AmortizingCmsRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingCmsRateBond__SWIG_7(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Natural arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  ext::shared_ptr< SwapIndex > tempnull4 ;
  AmortizingCmsRateBond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< SwapIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  {
    try {
      result = (AmortizingCmsRateBond *)new AmortizingCmsRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  AmortizingCmsRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AmortizingCmsRateBond__SWIG_8(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Natural arg1 ;
  std::vector< Real > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull4 ;
  AmortizingCmsRateBond *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< SwapIndex > *)jarg4 : &tempnull4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AmortizingCmsRateBond *)new AmortizingCmsRateBond(arg1,(std::vector< Real > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  AmortizingCmsRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AmortizingCmsRateBond(void * jarg1) {
  AmortizingCmsRateBond *arg1 = (AmortizingCmsRateBond *) 0 ;
  ext::shared_ptr< AmortizingCmsRateBond > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AmortizingCmsRateBond > *)jarg1;
  arg1 = (AmortizingCmsRateBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  DiscountingBondEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DiscountingBondEngine *)new DiscountingBondEngine((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 = result ? new ext::shared_ptr<  DiscountingBondEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DiscountingBondEngine(void * jarg1) {
  DiscountingBondEngine *arg1 = (DiscountingBondEngine *) 0 ;
  ext::shared_ptr< DiscountingBondEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DiscountingBondEngine > *)jarg1;
  arg1 = (DiscountingBondEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Callability(void * jarg1, int jarg2, void * jarg3) {
  void * jresult ;
  BondPrice *arg1 = 0 ;
  Callability::Type arg2 ;
  Date *arg3 = 0 ;
  Callability *result = 0 ;
  
  arg1 = (BondPrice *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPrice const & is null", 0);
    return 0;
  } 
  arg2 = (Callability::Type)jarg2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Callability *)new Callability((BondPrice 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 = result ? new ext::shared_ptr<  Callability >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Callability_price(void * jarg1) {
  void * jresult ;
  Callability *arg1 = (Callability *) 0 ;
  ext::shared_ptr< Callability const > *smartarg1 = 0 ;
  BondPrice *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const Callability > *)jarg1;
  arg1 = (Callability *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (BondPrice *) &((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 ;
  ext::shared_ptr< Callability const > *smartarg1 = 0 ;
  Callability::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const Callability > *)jarg1;
  arg1 = (Callability *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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 ;
  ext::shared_ptr< Callability const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const Callability > *)jarg1;
  arg1 = (Callability *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Callability(void * jarg1) {
  Callability *arg1 = (Callability *) 0 ;
  ext::shared_ptr< Callability > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Callability > *)jarg1;
  arg1 = (Callability *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SoftCallability(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  BondPrice *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  SoftCallability *result = 0 ;
  
  arg1 = (BondPrice *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPrice const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (SoftCallability *)new SoftCallability((BondPrice 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 = result ? new ext::shared_ptr<  SoftCallability >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SoftCallability(void * jarg1) {
  SoftCallability *arg1 = (SoftCallability *) 0 ;
  ext::shared_ptr< SoftCallability > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SoftCallability > *)jarg1;
  arg1 = (SoftCallability *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  
  arg1 = (std::vector< ext::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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  ext::shared_ptr< Callability > *arg2 = 0 ;
  ext::shared_ptr< Callability > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Callability > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = (std::vector< ext::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< ext::shared_ptr< Callability > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< Callability > > *)new std::vector< ext::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< ext::shared_ptr< Callability > > *arg1 = 0 ;
  std::vector< ext::shared_ptr< Callability > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< ext::shared_ptr< Callability > > *)new std::vector< ext::shared_ptr< Callability > >((std::vector< ext::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< ext::shared_ptr< Callability > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Callability > > *)new_std_vector_Sl_ext_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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< Callability > result;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_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 = result ? new ext::shared_ptr< Callability >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Callability > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Callability > >::value_type *) &std_vector_Sl_ext_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 = *result ? new std::vector< ext::shared_ptr< Callability > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CallabilitySchedule_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< Callability > *arg3 = 0 ;
  ext::shared_ptr< Callability > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< Callability > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__setitem(arg1,arg2,(ext::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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< Callability > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__AddRange(arg1,(std::vector< ext::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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< Callability > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Callability > > *)std_vector_Sl_ext_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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< Callability > *arg3 = 0 ;
  ext::shared_ptr< Callability > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< Callability > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__Insert(arg1,arg2,(ext::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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Callability > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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 ;
  ext::shared_ptr< Callability > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< Callability > tempnull1 ;
  std::vector< ext::shared_ptr< Callability > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Callability > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Callability > > *)std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__Repeat((ext::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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Callability > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  ext::shared_ptr< Callability > *arg2 = 0 ;
  ext::shared_ptr< Callability > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Callability > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__Contains(arg1,(ext::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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  ext::shared_ptr< Callability > *arg2 = 0 ;
  ext::shared_ptr< Callability > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Callability > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__IndexOf(arg1,(ext::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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  ext::shared_ptr< Callability > *arg2 = 0 ;
  ext::shared_ptr< Callability > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Callability > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__LastIndexOf(arg1,(ext::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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  ext::shared_ptr< Callability > *arg2 = 0 ;
  ext::shared_ptr< Callability > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< Callability > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Callability > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__Remove(arg1,(ext::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< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  
  arg1 = (std::vector< ext::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_CallableBond_callability(void * jarg1) {
  void * jresult ;
  CallableBond *arg1 = (CallableBond *) 0 ;
  ext::shared_ptr< CallableBond const > *smartarg1 = 0 ;
  std::vector< ext::shared_ptr< Callability > > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const CallableBond > *)jarg1;
  arg1 = (CallableBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< ext::shared_ptr< Callability > > *) &((CallableBond const *)arg1)->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 double SWIGSTDCALL CSharp_QuantLib_CallableBond_impliedVolatility(void * jarg1, void * jarg2, void * jarg3, double jarg4, unsigned long jarg5, double jarg6, double jarg7) {
  double jresult ;
  CallableBond *arg1 = (CallableBond *) 0 ;
  BondPrice *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  Volatility arg7 ;
  ext::shared_ptr< CallableBond const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const CallableBond > *)jarg1;
  arg1 = (CallableBond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (BondPrice *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BondPrice const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Volatility)jarg6; 
  arg7 = (Volatility)jarg7; 
  {
    try {
      result = (Volatility)((CallableBond const *)arg1)->impliedVolatility((BondPrice const &)*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_CallableBond_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 ;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Size arg9 ;
  Spread arg10 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CallableBond > *)jarg1;
  arg1 = (CallableBond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  arg9 = (Size)jarg9; 
  arg10 = (Spread)jarg10; 
  {
    try {
      result = (Real)(arg1)->OAS(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_CallableBond_OAS__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8, unsigned long jarg9) {
  double jresult ;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Size arg9 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CallableBond > *)jarg1;
  arg1 = (CallableBond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  arg9 = (Size)jarg9; 
  {
    try {
      result = (Real)(arg1)->OAS(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_CallableBond_OAS__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7, double jarg8) {
  double jresult ;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CallableBond > *)jarg1;
  arg1 = (CallableBond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (Real)(arg1)->OAS(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_CallableBond_OAS__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7) {
  double jresult ;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date *arg7 = 0 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CallableBond > *)jarg1;
  arg1 = (CallableBond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(arg1)->OAS(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_CallableBond_OAS__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  double jresult ;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CallableBond > *)jarg1;
  arg1 = (CallableBond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Real)(arg1)->OAS(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_CallableBond_cleanPriceOAS__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, void * jarg7) {
  double jresult ;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  Date *argp7 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CallableBond > *)jarg1;
  arg1 = (CallableBond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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)(arg1)->cleanPriceOAS(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_CallableBond_cleanPriceOAS__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  double jresult ;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CallableBond > *)jarg1;
  arg1 = (CallableBond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Real)(arg1)->cleanPriceOAS(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_CallableBond_effectiveDuration__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, double jarg7) {
  double jresult ;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Real arg7 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CallableBond > *)jarg1;
  arg1 = (CallableBond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (Real)(arg1)->effectiveDuration(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_CallableBond_effectiveDuration__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  double jresult ;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CallableBond > *)jarg1;
  arg1 = (CallableBond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Real)(arg1)->effectiveDuration(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_CallableBond_effectiveConvexity__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6, double jarg7) {
  double jresult ;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Real arg7 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CallableBond > *)jarg1;
  arg1 = (CallableBond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (Real)(arg1)->effectiveConvexity(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_CallableBond_effectiveConvexity__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  double jresult ;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CallableBond > *)jarg1;
  arg1 = (CallableBond *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Real)(arg1)->effectiveConvexity(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_CallableBond(void * jarg1) {
  CallableBond *arg1 = (CallableBond *) 0 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CallableBond > *)jarg1;
  arg1 = (CallableBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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__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 ;
  std::vector< ext::shared_ptr< Callability > > *arg9 = 0 ;
  Period *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  BusinessDayConvention arg12 ;
  bool arg13 ;
  Date *argp8 ;
  CallableFixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< Callability > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg12 = (BusinessDayConvention)jarg12; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (CallableFixedRateBond *)new CallableFixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,arg8,(std::vector< ext::shared_ptr< Callability > > 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 = result ? new ext::shared_ptr<  CallableFixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CallableFixedRateBond__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 ;
  std::vector< ext::shared_ptr< Callability > > *arg9 = 0 ;
  Period *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  BusinessDayConvention arg12 ;
  Date *argp8 ;
  CallableFixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< Callability > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg12 = (BusinessDayConvention)jarg12; 
  {
    try {
      result = (CallableFixedRateBond *)new CallableFixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,arg8,(std::vector< ext::shared_ptr< Callability > > 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 = result ? new ext::shared_ptr<  CallableFixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CallableFixedRateBond__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 ;
  std::vector< ext::shared_ptr< Callability > > *arg9 = 0 ;
  Period *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  Date *argp8 ;
  CallableFixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< Callability > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CallableFixedRateBond *)new CallableFixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,arg8,(std::vector< ext::shared_ptr< Callability > > 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 = result ? new ext::shared_ptr<  CallableFixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CallableFixedRateBond__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 ;
  std::vector< ext::shared_ptr< Callability > > *arg9 = 0 ;
  Period *arg10 = 0 ;
  Date *argp8 ;
  CallableFixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< Callability > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CallableFixedRateBond *)new CallableFixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,arg8,(std::vector< ext::shared_ptr< Callability > > 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 = result ? new ext::shared_ptr<  CallableFixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CallableFixedRateBond__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 ;
  std::vector< ext::shared_ptr< Callability > > *arg9 = 0 ;
  Date *argp8 ;
  CallableFixedRateBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Schedule *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Rate > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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< ext::shared_ptr< Callability > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CallableFixedRateBond *)new CallableFixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,arg8,(std::vector< ext::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 = result ? new ext::shared_ptr<  CallableFixedRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CallableFixedRateBond(void * jarg1) {
  CallableFixedRateBond *arg1 = (CallableFixedRateBond *) 0 ;
  ext::shared_ptr< CallableFixedRateBond > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CallableFixedRateBond > *)jarg1;
  arg1 = (CallableFixedRateBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CallableZeroCouponBond__SWIG_0(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, double jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Calendar *arg3 = 0 ;
  Date *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Real arg7 ;
  Date *arg8 = 0 ;
  std::vector< ext::shared_ptr< Callability > > *arg9 = 0 ;
  CallableZeroCouponBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< ext::shared_ptr< Callability > > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CallableZeroCouponBond *)new CallableZeroCouponBond(arg1,arg2,(Calendar const &)*arg3,(Date const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(Date const &)*arg8,(std::vector< ext::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 = result ? new ext::shared_ptr<  CallableZeroCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CallableZeroCouponBond__SWIG_1(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, double jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Calendar *arg3 = 0 ;
  Date *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Real arg7 ;
  Date *arg8 = 0 ;
  CallableZeroCouponBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Date *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CallableZeroCouponBond *)new CallableZeroCouponBond(arg1,arg2,(Calendar const &)*arg3,(Date const &)*arg4,(DayCounter const &)*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 ? new ext::shared_ptr<  CallableZeroCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CallableZeroCouponBond__SWIG_2(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, double jarg7) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Calendar *arg3 = 0 ;
  Date *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Real arg7 ;
  CallableZeroCouponBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (CallableZeroCouponBond *)new CallableZeroCouponBond(arg1,arg2,(Calendar const &)*arg3,(Date 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 = result ? new ext::shared_ptr<  CallableZeroCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CallableZeroCouponBond__SWIG_3(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Calendar *arg3 = 0 ;
  Date *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  CallableZeroCouponBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  {
    try {
      result = (CallableZeroCouponBond *)new CallableZeroCouponBond(arg1,arg2,(Calendar const &)*arg3,(Date 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 = result ? new ext::shared_ptr<  CallableZeroCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CallableZeroCouponBond__SWIG_4(int jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Real arg2 ;
  Calendar *arg3 = 0 ;
  Date *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  CallableZeroCouponBond *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CallableZeroCouponBond *)new CallableZeroCouponBond(arg1,arg2,(Calendar const &)*arg3,(Date 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 = result ? new ext::shared_ptr<  CallableZeroCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CallableZeroCouponBond(void * jarg1) {
  CallableZeroCouponBond *arg1 = (CallableZeroCouponBond *) 0 ;
  ext::shared_ptr< CallableZeroCouponBond > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CallableZeroCouponBond > *)jarg1;
  arg1 = (CallableZeroCouponBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< ShortRateModel > tempnull1 ;
  TreeCallableFixedRateBondEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ShortRateModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeCallableFixedRateBondEngine *)new TreeCallableFixedRateBondEngine((ext::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 = result ? new ext::shared_ptr<  TreeCallableFixedRateBondEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeCallableFixedRateBondEngine__SWIG_1(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< ShortRateModel > tempnull1 ;
  TreeCallableFixedRateBondEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ShortRateModel > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (TreeCallableFixedRateBondEngine *)new TreeCallableFixedRateBondEngine((ext::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 = result ? new ext::shared_ptr<  TreeCallableFixedRateBondEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeCallableFixedRateBondEngine__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< ShortRateModel > tempnull1 ;
  TreeCallableFixedRateBondEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ShortRateModel > *)jarg1 : &tempnull1; 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeCallableFixedRateBondEngine *)new TreeCallableFixedRateBondEngine((ext::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 = result ? new ext::shared_ptr<  TreeCallableFixedRateBondEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TreeCallableFixedRateBondEngine__SWIG_3(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  ext::shared_ptr< ShortRateModel > tempnull1 ;
  TreeCallableFixedRateBondEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ShortRateModel > *)jarg1 : &tempnull1; 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (TreeCallableFixedRateBondEngine *)new TreeCallableFixedRateBondEngine((ext::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 = result ? new ext::shared_ptr<  TreeCallableFixedRateBondEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_TreeCallableFixedRateBondEngine(void * jarg1) {
  TreeCallableFixedRateBondEngine *arg1 = (TreeCallableFixedRateBondEngine *) 0 ;
  ext::shared_ptr< TreeCallableFixedRateBondEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  TreeCallableFixedRateBondEngine > *)jarg1;
  arg1 = (TreeCallableFixedRateBondEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  BlackCallableFixedRateBondEngine *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackCallableFixedRateBondEngine *)new BlackCallableFixedRateBondEngine((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 = result ? new ext::shared_ptr<  BlackCallableFixedRateBondEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackCallableFixedRateBondEngine(void * jarg1) {
  BlackCallableFixedRateBondEngine *arg1 = (BlackCallableFixedRateBondEngine *) 0 ;
  ext::shared_ptr< BlackCallableFixedRateBondEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackCallableFixedRateBondEngine > *)jarg1;
  arg1 = (BlackCallableFixedRateBondEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< ZeroInflationIndex > *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 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPIBond *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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (BusinessDayConvention)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (Period *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg15 = (Calendar *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg16 = (BusinessDayConvention)jarg16; 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = (CPIBond *)new CPIBond(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CPIBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< ZeroInflationIndex > *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 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPIBond *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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (BusinessDayConvention)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (Period *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg15 = (Calendar *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg16 = (BusinessDayConvention)jarg16; 
  {
    try {
      result = (CPIBond *)new CPIBond(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CPIBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< ZeroInflationIndex > *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 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPIBond *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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (BusinessDayConvention)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (Period *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg15 = (Calendar *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPIBond *)new CPIBond(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CPIBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< ZeroInflationIndex > *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 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPIBond *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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (BusinessDayConvention)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (Period *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPIBond *)new CPIBond(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CPIBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Schedule *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  BusinessDayConvention arg11 ;
  Date *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPIBond *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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (BusinessDayConvention)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPIBond *)new CPIBond(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CPIBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Schedule *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  BusinessDayConvention arg11 ;
  Date *arg12 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPIBond *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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (BusinessDayConvention)jarg11; 
  arg12 = (Date *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPIBond *)new CPIBond(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CPIBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Schedule *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  BusinessDayConvention arg11 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPIBond *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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg11 = (BusinessDayConvention)jarg11; 
  {
    try {
      result = (CPIBond *)new CPIBond(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CPIBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Schedule *arg8 = 0 ;
  std::vector< Rate > *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempnull6 ;
  CPIBond *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 & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< ZeroInflationIndex > *)jarg6 : &tempnull6; 
  arg7 = (CPI::InterpolationType)jarg7; 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (DayCounter *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CPIBond *)new CPIBond(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CPIBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CPIBond(void * jarg1) {
  CPIBond *arg1 = (CPIBond *) 0 ;
  ext::shared_ptr< CPIBond > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CPIBond > *)jarg1;
  arg1 = (CPIBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  Bond *arg1 = 0 ;
  Date result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = BondFunctions::startDate((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_maturityDate(void * jarg1) {
  void * jresult ;
  Bond *arg1 = 0 ;
  Date result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = BondFunctions::maturityDate((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_BondFunctions_isTradable__SWIG_0(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Bond *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  bool result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference 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((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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 ;
  Bond *arg1 = 0 ;
  bool result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)BondFunctions::isTradable((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Date result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference 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((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_previousCashFlowDate__SWIG_1(void * jarg1) {
  void * jresult ;
  Bond *arg1 = 0 ;
  Date result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = BondFunctions::previousCashFlowDate((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_nextCashFlowDate__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Bond *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Date result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference 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((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_nextCashFlowDate__SWIG_1(void * jarg1) {
  void * jresult ;
  Bond *arg1 = 0 ;
  Date result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = BondFunctions::nextCashFlowDate((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_previousCashFlowAmount__SWIG_0(void * jarg1, void * jarg2) {
  double jresult ;
  Bond *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference 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((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions::previousCashFlowAmount((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference 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((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions::nextCashFlowAmount((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Rate result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference 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((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  Rate result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)BondFunctions::previousCouponRate((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Rate result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference 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((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  Rate result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)BondFunctions::nextCouponRate((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Date result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference 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((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_accrualStartDate__SWIG_1(void * jarg1) {
  void * jresult ;
  Bond *arg1 = 0 ;
  Date result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = BondFunctions::accrualStartDate((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_accrualEndDate__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  Bond *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Date result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference 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((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondFunctions_accrualEndDate__SWIG_1(void * jarg1) {
  void * jresult ;
  Bond *arg1 = 0 ;
  Date result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = BondFunctions::accrualEndDate((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondFunctions_accrualPeriod__SWIG_0(void * jarg1, void * jarg2) {
  double jresult ;
  Bond *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Time result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference 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((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  Time result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)BondFunctions::accrualPeriod((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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 ;
  Bond *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  BigInteger result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference 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((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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 ;
  Bond *arg1 = 0 ;
  BigInteger result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (BigInteger)BondFunctions::accrualDays((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Time result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference 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((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  Time result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)BondFunctions::accruedPeriod((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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 ;
  Bond *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  BigInteger result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference 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((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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 ;
  Bond *arg1 = 0 ;
  BigInteger result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (BigInteger)BondFunctions::accruedDays((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  Date arg2 ;
  Date *argp2 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference 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((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions::accruedAmount((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  YieldTermStructure *arg2 = 0 ;
  Date arg3 ;
  Date *argp3 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  
  arg2 = (YieldTermStructure *)(((ext::shared_ptr< const YieldTermStructure > *)jarg2) ? ((ext::shared_ptr< const YieldTermStructure > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "YieldTermStructure const & reference 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((Bond const &)*arg1,(YieldTermStructure const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  YieldTermStructure *arg2 = 0 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  
  arg2 = (YieldTermStructure *)(((ext::shared_ptr< const YieldTermStructure > *)jarg2) ? ((ext::shared_ptr< const YieldTermStructure > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "YieldTermStructure const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions::cleanPrice((Bond const &)*arg1,(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 ;
  Bond *arg1 = 0 ;
  YieldTermStructure *arg2 = 0 ;
  Date arg3 ;
  Date *argp3 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  
  arg2 = (YieldTermStructure *)(((ext::shared_ptr< const YieldTermStructure > *)jarg2) ? ((ext::shared_ptr< const YieldTermStructure > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "YieldTermStructure const & reference 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((Bond const &)*arg1,(YieldTermStructure const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  YieldTermStructure *arg2 = 0 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  
  arg2 = (YieldTermStructure *)(((ext::shared_ptr< const YieldTermStructure > *)jarg2) ? ((ext::shared_ptr< const YieldTermStructure > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "YieldTermStructure const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions::bps((Bond const &)*arg1,(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 ;
  Bond *arg1 = 0 ;
  YieldTermStructure *arg2 = 0 ;
  Date arg3 ;
  Real arg4 ;
  Date *argp3 ;
  Rate result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  
  arg2 = (YieldTermStructure *)(((ext::shared_ptr< const YieldTermStructure > *)jarg2) ? ((ext::shared_ptr< const YieldTermStructure > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "YieldTermStructure const & reference 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((Bond const &)*arg1,(YieldTermStructure const &)*arg2,SWIG_STD_MOVE(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 ;
  Bond *arg1 = 0 ;
  YieldTermStructure *arg2 = 0 ;
  Date arg3 ;
  Date *argp3 ;
  Rate result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  
  arg2 = (YieldTermStructure *)(((ext::shared_ptr< const YieldTermStructure > *)jarg2) ? ((ext::shared_ptr< const YieldTermStructure > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "YieldTermStructure const & reference 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((Bond const &)*arg1,(YieldTermStructure const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  YieldTermStructure *arg2 = 0 ;
  Rate result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  
  arg2 = (YieldTermStructure *)(((ext::shared_ptr< const YieldTermStructure > *)jarg2) ? ((ext::shared_ptr< const YieldTermStructure > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "YieldTermStructure const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)BondFunctions::atmRate((Bond const &)*arg1,(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 ;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Date arg3 ;
  Date *argp3 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & 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((Bond const &)*arg1,(InterestRate const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions::cleanPrice((Bond 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 ;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Date *argp6 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(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 ;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Real)BondFunctions::cleanPrice((Bond 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 ;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Date arg3 ;
  Date *argp3 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & 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((Bond const &)*arg1,(InterestRate const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions::bps((Bond 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 ;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Date *argp6 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(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 ;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Real)BondFunctions::bps((Bond 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 ;
  Bond *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Real arg7 ;
  Size arg8 ;
  Rate arg9 ;
  Date *argp6 ;
  Rate result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(arg6),arg7,SWIG_STD_MOVE(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 ;
  Bond *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Real arg7 ;
  Size arg8 ;
  Date *argp6 ;
  Rate result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(arg6),arg7,SWIG_STD_MOVE(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 ;
  Bond *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Real arg7 ;
  Date *argp6 ;
  Rate result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(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 ;
  Bond *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Date *argp6 ;
  Rate result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(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 ;
  Bond *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Rate result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Rate)BondFunctions::yield((Bond 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_duration__SWIG_0(void * jarg1, void * jarg2, int jarg3, void * jarg4) {
  double jresult ;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Duration::Type arg3 ;
  Date arg4 ;
  Date *argp4 ;
  Time result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & 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((Bond const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(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 ;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Duration::Type arg3 ;
  Time result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & is null", 0);
    return 0;
  } 
  arg3 = (Duration::Type)jarg3; 
  {
    try {
      result = (Time)BondFunctions::duration((Bond 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 ;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Time result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)BondFunctions::duration((Bond 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 ;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Duration::Type arg6 ;
  Date arg7 ;
  Date *argp7 ;
  Time result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Duration::Type arg6 ;
  Time result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  arg6 = (Duration::Type)jarg6; 
  {
    try {
      result = (Time)BondFunctions::duration((Bond 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 ;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Time result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Time)BondFunctions::duration((Bond 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 ;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Date arg3 ;
  Date *argp3 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & 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((Bond const &)*arg1,(InterestRate const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions::convexity((Bond 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 ;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Date *argp6 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(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 ;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Real)BondFunctions::convexity((Bond 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 ;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Date arg3 ;
  Date *argp3 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & 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((Bond const &)*arg1,(InterestRate const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions::basisPointValue((Bond 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 ;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Date *argp6 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(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 ;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Real)BondFunctions::basisPointValue((Bond 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 ;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Date arg3 ;
  Date *argp3 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & 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((Bond const &)*arg1,(InterestRate const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (InterestRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InterestRate const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)BondFunctions::yieldValueBasisPoint((Bond 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 ;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Date *argp6 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(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 ;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Real result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Compounding)jarg4; 
  arg5 = (Frequency)jarg5; 
  {
    try {
      result = (Real)BondFunctions::yieldValueBasisPoint((Bond 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 ;
  Bond *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Size arg9 ;
  Rate arg10 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  Date *argp7 ;
  Spread result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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((Bond const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8,SWIG_STD_MOVE(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 ;
  Bond *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Size arg9 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  Date *argp7 ;
  Spread result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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((Bond const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8,SWIG_STD_MOVE(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 ;
  Bond *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  Date *argp7 ;
  Spread result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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((Bond const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  Date *argp7 ;
  Spread result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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((Bond const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  Spread result;
  
  
  arg1 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg1) ? ((ext::shared_ptr< const Bond > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Spread)BondFunctions::zSpread((Bond const &)*arg1,arg2,(ext::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 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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Rate)BondFunctions_yieldBrent__SWIG_0(SWIG_STD_MOVE(arg1),(Bond 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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Rate)BondFunctions_yieldBisection__SWIG_0(SWIG_STD_MOVE(arg1),(Bond 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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Rate)BondFunctions_yieldFalsePosition__SWIG_0(SWIG_STD_MOVE(arg1),(Bond 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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Rate)BondFunctions_yieldRidder__SWIG_0(SWIG_STD_MOVE(arg1),(Bond 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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & 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(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(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 ;
  Bond *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 = (Bond *)(((ext::shared_ptr< const Bond > *)jarg2) ? ((ext::shared_ptr< const Bond > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Bond const & reference is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Compounding)jarg5; 
  arg6 = (Frequency)jarg6; 
  {
    try {
      result = (Rate)BondFunctions_yieldSecant__SWIG_0(SWIG_STD_MOVE(arg1),(Bond 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_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 void SWIGSTDCALL CSharp_QuantLib_BlackCalibrationHelper_setPricingEngine(void * jarg1, void * jarg2) {
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  ext::shared_ptr< PricingEngine > *arg2 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper > *smartarg1 = 0 ;
  ext::shared_ptr< PricingEngine > tempnull2 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackCalibrationHelper > *)jarg1;
  arg1 = (BlackCalibrationHelper *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (ext::shared_ptr< PricingEngine > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->setPricingEngine((ext::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_BlackCalibrationHelper_marketValue(void * jarg1) {
  double jresult ;
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  ext::shared_ptr< BlackCalibrationHelper const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackCalibrationHelper > *)jarg1;
  arg1 = (BlackCalibrationHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((BlackCalibrationHelper 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_BlackCalibrationHelper_modelValue(void * jarg1) {
  double jresult ;
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  ext::shared_ptr< BlackCalibrationHelper const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackCalibrationHelper > *)jarg1;
  arg1 = (BlackCalibrationHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((BlackCalibrationHelper 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_BlackCalibrationHelper_impliedVolatility(void * jarg1, double jarg2, double jarg3, unsigned long jarg4, double jarg5, double jarg6) {
  double jresult ;
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Size arg4 ;
  Volatility arg5 ;
  Volatility arg6 ;
  ext::shared_ptr< BlackCalibrationHelper > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  BlackCalibrationHelper > *)jarg1;
  arg1 = (BlackCalibrationHelper *)(smartarg1 ? smartarg1->get() : 0); 
  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_BlackCalibrationHelper_blackPrice(void * jarg1, double jarg2) {
  double jresult ;
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  Volatility arg2 ;
  ext::shared_ptr< BlackCalibrationHelper > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  BlackCalibrationHelper > *)jarg1;
  arg1 = (BlackCalibrationHelper *)(smartarg1 ? smartarg1->get() : 0); 
  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_BlackCalibrationHelper_volatility(void * jarg1) {
  void * jresult ;
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  ext::shared_ptr< BlackCalibrationHelper const > *smartarg1 = 0 ;
  Handle< Quote > result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackCalibrationHelper > *)jarg1;
  arg1 = (BlackCalibrationHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BlackCalibrationHelper 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 >(result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_BlackCalibrationHelper_volatilityType(void * jarg1) {
  int jresult ;
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  ext::shared_ptr< BlackCalibrationHelper const > *smartarg1 = 0 ;
  VolatilityType result;
  
  
  smartarg1 = (ext::shared_ptr< const BlackCalibrationHelper > *)jarg1;
  arg1 = (BlackCalibrationHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (VolatilityType)((BlackCalibrationHelper 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 double SWIGSTDCALL CSharp_QuantLib_BlackCalibrationHelper_calibrationError(void * jarg1) {
  double jresult ;
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  ext::shared_ptr< BlackCalibrationHelper > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  BlackCalibrationHelper > *)jarg1;
  arg1 = (BlackCalibrationHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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 void SWIGSTDCALL CSharp_QuantLib_delete_BlackCalibrationHelper(void * jarg1) {
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  ext::shared_ptr< BlackCalibrationHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackCalibrationHelper > *)jarg1;
  arg1 = (BlackCalibrationHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_black_helper(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< CalibrationHelper > *arg1 = 0 ;
  ext::shared_ptr< CalibrationHelper > tempnull1 ;
  ext::shared_ptr< BlackCalibrationHelper > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< CalibrationHelper > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_black_helper((ext::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 = result ? new ext::shared_ptr< BlackCalibrationHelper >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_as_swaption_helper(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< BlackCalibrationHelper > *arg1 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper > tempnull1 ;
  ext::shared_ptr< SwaptionHelper > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< BlackCalibrationHelper > *)jarg1 : &tempnull1; 
  {
    try {
      result = as_swaption_helper((ext::shared_ptr< BlackCalibrationHelper > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new ext::shared_ptr< SwaptionHelper >(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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  Real arg13 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg9 = (BlackCalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (VolatilityType)jarg12; 
  arg13 = (Real)jarg13; 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg9 = (BlackCalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (VolatilityType)jarg12; 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg9 = (BlackCalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg9 = (BlackCalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg9 = (BlackCalibrationHelper::CalibrationErrorType)jarg9; 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  Real arg13 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg9 = (BlackCalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (VolatilityType)jarg12; 
  arg13 = (Real)jarg13; 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg9 = (BlackCalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (VolatilityType)jarg12; 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg9 = (BlackCalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg9 = (BlackCalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg9 = (BlackCalibrationHelper::CalibrationErrorType)jarg9; 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  Real arg13 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg9 = (BlackCalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (VolatilityType)jarg12; 
  arg13 = (Real)jarg13; 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg9 = (BlackCalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (VolatilityType)jarg12; 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg9 = (BlackCalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg9 = (BlackCalibrationHelper::CalibrationErrorType)jarg9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg9 = (BlackCalibrationHelper::CalibrationErrorType)jarg9; 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  SwaptionHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Period *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< YieldTermStructure > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionHelper_underlyingSwap(void * jarg1) {
  void * jresult ;
  SwaptionHelper *arg1 = (SwaptionHelper *) 0 ;
  ext::shared_ptr< SwaptionHelper const > *smartarg1 = 0 ;
  ext::shared_ptr< VanillaSwap > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionHelper > *)jarg1;
  arg1 = (SwaptionHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((SwaptionHelper const *)arg1)->underlyingSwap();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< VanillaSwap >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionHelper_swaption(void * jarg1) {
  void * jresult ;
  SwaptionHelper *arg1 = (SwaptionHelper *) 0 ;
  ext::shared_ptr< SwaptionHelper const > *smartarg1 = 0 ;
  ext::shared_ptr< Swaption > result;
  
  
  smartarg1 = (ext::shared_ptr< const SwaptionHelper > *)jarg1;
  arg1 = (SwaptionHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((SwaptionHelper const *)arg1)->swaption();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new ext::shared_ptr< Swaption >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionHelper_times(void * jarg1) {
  void * jresult ;
  SwaptionHelper *arg1 = (SwaptionHelper *) 0 ;
  ext::shared_ptr< SwaptionHelper > *smartarg1 = 0 ;
  std::vector< Time > result;
  
  
  smartarg1 = (ext::shared_ptr<  SwaptionHelper > *)jarg1;
  arg1 = (SwaptionHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = SwaptionHelper_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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwaptionHelper_swaptionExpiryDate(void * jarg1) {
  void * jresult ;
  SwaptionHelper *arg1 = (SwaptionHelper *) 0 ;
  ext::shared_ptr< SwaptionHelper > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr<  SwaptionHelper > *)jarg1;
  arg1 = (SwaptionHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = SwaptionHelper_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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwaptionHelper_swaptionStrike(void * jarg1) {
  double jresult ;
  SwaptionHelper *arg1 = (SwaptionHelper *) 0 ;
  ext::shared_ptr< SwaptionHelper > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  SwaptionHelper > *)jarg1;
  arg1 = (SwaptionHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)SwaptionHelper_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_SwaptionHelper_swaptionNominal(void * jarg1) {
  double jresult ;
  SwaptionHelper *arg1 = (SwaptionHelper *) 0 ;
  ext::shared_ptr< SwaptionHelper > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  SwaptionHelper > *)jarg1;
  arg1 = (SwaptionHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)SwaptionHelper_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_SwaptionHelper_swaptionMaturityDate(void * jarg1) {
  void * jresult ;
  SwaptionHelper *arg1 = (SwaptionHelper *) 0 ;
  ext::shared_ptr< SwaptionHelper > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr<  SwaptionHelper > *)jarg1;
  arg1 = (SwaptionHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = SwaptionHelper_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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SwaptionHelper(void * jarg1) {
  SwaptionHelper *arg1 = (SwaptionHelper *) 0 ;
  ext::shared_ptr< SwaptionHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SwaptionHelper > *)jarg1;
  arg1 = (SwaptionHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, int jarg9, double jarg10) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Frequency arg4 ;
  DayCounter *arg5 = 0 ;
  bool arg6 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg8 ;
  VolatilityType arg9 ;
  Real arg10 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  CapHelper *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg8 = (BlackCalibrationHelper::CalibrationErrorType)jarg8; 
  arg9 = (VolatilityType)jarg9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (CapHelper *)new CapHelper((Period const &)*arg1,(Handle< Quote > const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4,(DayCounter const &)*arg5,arg6,(Handle< YieldTermStructure > 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 ? new ext::shared_ptr<  CapHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, int jarg8, int jarg9) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Frequency arg4 ;
  DayCounter *arg5 = 0 ;
  bool arg6 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg8 ;
  VolatilityType arg9 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  CapHelper *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg8 = (BlackCalibrationHelper::CalibrationErrorType)jarg8; 
  arg9 = (VolatilityType)jarg9; 
  {
    try {
      result = (CapHelper *)new CapHelper((Period const &)*arg1,(Handle< Quote > const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4,(DayCounter const &)*arg5,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 = result ? new ext::shared_ptr<  CapHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapHelper__SWIG_2(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 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Frequency arg4 ;
  DayCounter *arg5 = 0 ;
  bool arg6 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg8 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  CapHelper *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg8 = (BlackCalibrationHelper::CalibrationErrorType)jarg8; 
  {
    try {
      result = (CapHelper *)new CapHelper((Period const &)*arg1,(Handle< Quote > const &)*arg2,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  CapHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapHelper__SWIG_3(void * jarg1, void * jarg2, void * jarg3, int jarg4, void * jarg5, unsigned int jarg6, void * jarg7) {
  void * jresult ;
  Period *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Frequency arg4 ;
  DayCounter *arg5 = 0 ;
  bool arg6 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  CapHelper *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapHelper *)new CapHelper((Period const &)*arg1,(Handle< Quote > const &)*arg2,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  CapHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapHelper_times(void * jarg1) {
  void * jresult ;
  CapHelper *arg1 = (CapHelper *) 0 ;
  ext::shared_ptr< CapHelper > *smartarg1 = 0 ;
  std::vector< Time > result;
  
  
  smartarg1 = (ext::shared_ptr<  CapHelper > *)jarg1;
  arg1 = (CapHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = CapHelper_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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CapHelper(void * jarg1) {
  CapHelper *arg1 = (CapHelper *) 0 ;
  ext::shared_ptr< CapHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CapHelper > *)jarg1;
  arg1 = (CapHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  BlackCalibrationHelper::CalibrationErrorType arg8 ;
  HestonModelHelper *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg8 = (BlackCalibrationHelper::CalibrationErrorType)jarg8; 
  {
    try {
      result = (HestonModelHelper *)new HestonModelHelper((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 = result ? new ext::shared_ptr<  HestonModelHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  HestonModelHelper *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (HestonModelHelper *)new HestonModelHelper((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 = result ? new ext::shared_ptr<  HestonModelHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HestonModelHelper(void * jarg1) {
  HestonModelHelper *arg1 = (HestonModelHelper *) 0 ;
  ext::shared_ptr< HestonModelHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  HestonModelHelper > *)jarg1;
  arg1 = (HestonModelHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BlackCalibrationHelperVector_Clear(void * jarg1) {
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)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_BlackCalibrationHelperVector_Add(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  ext::shared_ptr< BlackCalibrationHelper > *arg2 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BlackCalibrationHelper > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::shared_ptr< BlackCalibrationHelper > 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_BlackCalibrationHelperVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< BlackCalibrationHelper > > 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_BlackCalibrationHelperVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< BlackCalibrationHelper > > 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_BlackCalibrationHelperVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > >::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_BlackCalibrationHelperVector__SWIG_0() {
  void * jresult ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)new std::vector< ext::shared_ptr< BlackCalibrationHelper > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackCalibrationHelperVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)new_std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_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_BlackCalibrationHelperVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< BlackCalibrationHelper > result;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_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 = result ? new ext::shared_ptr< BlackCalibrationHelper >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackCalibrationHelperVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_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 = *result ? new std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BlackCalibrationHelperVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< BlackCalibrationHelper > *arg3 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< BlackCalibrationHelper > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__setitem(arg1,arg2,(ext::shared_ptr< BlackCalibrationHelper > 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_BlackCalibrationHelperVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__AddRange(arg1,(std::vector< ext::shared_ptr< BlackCalibrationHelper > > 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_BlackCalibrationHelperVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_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_BlackCalibrationHelperVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< BlackCalibrationHelper > *arg3 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< BlackCalibrationHelper > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__Insert(arg1,arg2,(ext::shared_ptr< BlackCalibrationHelper > 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_BlackCalibrationHelperVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::shared_ptr< BlackCalibrationHelper > > 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_BlackCalibrationHelperVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_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_BlackCalibrationHelperVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_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_BlackCalibrationHelperVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< BlackCalibrationHelper > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< BlackCalibrationHelper > tempnull1 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BlackCalibrationHelper > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__Repeat((ext::shared_ptr< BlackCalibrationHelper > 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_BlackCalibrationHelperVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_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_BlackCalibrationHelperVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_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_BlackCalibrationHelperVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::shared_ptr< BlackCalibrationHelper > > 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_BlackCalibrationHelperVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  ext::shared_ptr< BlackCalibrationHelper > *arg2 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BlackCalibrationHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__Contains(arg1,(ext::shared_ptr< BlackCalibrationHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_BlackCalibrationHelperVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  ext::shared_ptr< BlackCalibrationHelper > *arg2 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BlackCalibrationHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__IndexOf(arg1,(ext::shared_ptr< BlackCalibrationHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_BlackCalibrationHelperVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  ext::shared_ptr< BlackCalibrationHelper > *arg2 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BlackCalibrationHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__LastIndexOf(arg1,(ext::shared_ptr< BlackCalibrationHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_BlackCalibrationHelperVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  ext::shared_ptr< BlackCalibrationHelper > *arg2 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BlackCalibrationHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__Remove(arg1,(ext::shared_ptr< BlackCalibrationHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_BlackCalibrationHelperVector(void * jarg1) {
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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 ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  VolatilityType arg9 ;
  Real arg10 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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)((CapFloor const *)arg1)->impliedVolatility(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 ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  VolatilityType arg9 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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)((CapFloor const *)arg1)->impliedVolatility(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 ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Natural)jarg6; 
  arg7 = (Volatility)jarg7; 
  arg8 = (Volatility)jarg8; 
  {
    try {
      result = (Volatility)((CapFloor const *)arg1)->impliedVolatility(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 ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Natural)jarg6; 
  arg7 = (Volatility)jarg7; 
  {
    try {
      result = (Volatility)((CapFloor const *)arg1)->impliedVolatility(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 ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Natural)jarg6; 
  {
    try {
      result = (Volatility)((CapFloor const *)arg1)->impliedVolatility(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 ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Volatility)((CapFloor const *)arg1)->impliedVolatility(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 ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  {
    try {
      result = (Volatility)((CapFloor const *)arg1)->impliedVolatility(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 ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  Leg *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Leg *) &((CapFloor const *)arg1)->floatingLeg();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Rate > *) &(arg1)->capRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Rate > *) &(arg1)->floorRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((CapFloor const *)arg1)->startDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloor_maturityDate(void * jarg1) {
  void * jresult ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((CapFloor const *)arg1)->maturityDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_CapFloor_type(void * jarg1) {
  int jresult ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  CapFloor::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (CapFloor::Type)((CapFloor 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_CapFloor_atmRate(void * jarg1, void * jarg2) {
  double jresult ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  YieldTermStructure *arg2 = 0 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  
  arg2 = (YieldTermStructure *)(((ext::shared_ptr< const YieldTermStructure > *)jarg2) ? ((ext::shared_ptr< const YieldTermStructure > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "YieldTermStructure const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)((CapFloor const *)arg1)->atmRate((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_CapFloor_vega(void * jarg1) {
  double jresult ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)CapFloor_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_CapFloor_optionletsPrice(void * jarg1) {
  void * jresult ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  std::vector< Real > result;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = CapFloor_optionletsPrice(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloor_optionletsVega(void * jarg1) {
  void * jresult ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  std::vector< Real > result;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = CapFloor_optionletsVega(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloor_optionletsDelta(void * jarg1) {
  void * jresult ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  std::vector< Real > result;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = CapFloor_optionletsDelta(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloor_optionletsDiscountFactor(void * jarg1) {
  void * jresult ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  std::vector< DiscountFactor > result;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = CapFloor_optionletsDiscountFactor(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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< DiscountFactor >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloor_optionletsAtmForward(void * jarg1) {
  void * jresult ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  std::vector< Rate > result;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = CapFloor_optionletsAtmForward(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloor_optionletsStdDev(void * jarg1) {
  void * jresult ;
  CapFloor *arg1 = (CapFloor *) 0 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  std::vector< Rate > result;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = CapFloor_optionletsStdDev(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CapFloor(void * jarg1) {
  CapFloor *arg1 = (CapFloor *) 0 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloor > *)jarg1;
  arg1 = (CapFloor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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< ext::shared_ptr< CashFlow > > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  Cap *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CashFlow > > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Cap *)new Cap((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(std::vector< Rate > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  Cap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Cap(void * jarg1) {
  Cap *arg1 = (Cap *) 0 ;
  ext::shared_ptr< Cap > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Cap > *)jarg1;
  arg1 = (Cap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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< ext::shared_ptr< CashFlow > > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  Floor *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CashFlow > > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Floor *)new Floor((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(std::vector< Rate > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  Floor >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Floor(void * jarg1) {
  Floor *arg1 = (Floor *) 0 ;
  ext::shared_ptr< Floor > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Floor > *)jarg1;
  arg1 = (Floor *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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< ext::shared_ptr< CashFlow > > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Rate > *arg3 = 0 ;
  Collar *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< CashFlow > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CashFlow > > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Rate > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Collar *)new Collar((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1,(std::vector< Rate > const &)*arg2,(std::vector< Rate > 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 ? new ext::shared_ptr<  Collar >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Collar(void * jarg1) {
  Collar *arg1 = (Collar *) 0 ;
  ext::shared_ptr< Collar > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Collar > *)jarg1;
  arg1 = (Collar *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 * jarg3, double jarg4) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Real arg4 ;
  BlackCapFloorEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (BlackCapFloorEngine *)new BlackCapFloorEngine((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 = result ? new ext::shared_ptr<  BlackCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackCapFloorEngine__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  BlackCapFloorEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackCapFloorEngine *)new BlackCapFloorEngine((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 = result ? new ext::shared_ptr<  BlackCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackCapFloorEngine__SWIG_2(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  BlackCapFloorEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackCapFloorEngine *)new BlackCapFloorEngine((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 = result ? new ext::shared_ptr<  BlackCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackCapFloorEngine__SWIG_3(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< OptionletVolatilityStructure > *arg2 = 0 ;
  Real arg3 ;
  BlackCapFloorEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< OptionletVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< OptionletVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (BlackCapFloorEngine *)new BlackCapFloorEngine((Handle< YieldTermStructure > const &)*arg1,(Handle< OptionletVolatilityStructure > 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 ? new ext::shared_ptr<  BlackCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackCapFloorEngine__SWIG_4(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< OptionletVolatilityStructure > *arg2 = 0 ;
  BlackCapFloorEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< OptionletVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< OptionletVolatilityStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackCapFloorEngine *)new BlackCapFloorEngine((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 = result ? new ext::shared_ptr<  BlackCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackCapFloorEngine(void * jarg1) {
  BlackCapFloorEngine *arg1 = (BlackCapFloorEngine *) 0 ;
  ext::shared_ptr< BlackCapFloorEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackCapFloorEngine > *)jarg1;
  arg1 = (BlackCapFloorEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  BachelierCapFloorEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BachelierCapFloorEngine *)new BachelierCapFloorEngine((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 = result ? new ext::shared_ptr<  BachelierCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  BachelierCapFloorEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< OptionletVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< OptionletVolatilityStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BachelierCapFloorEngine *)new BachelierCapFloorEngine((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 = result ? new ext::shared_ptr<  BachelierCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BachelierCapFloorEngine(void * jarg1) {
  BachelierCapFloorEngine *arg1 = (BachelierCapFloorEngine *) 0 ;
  ext::shared_ptr< BachelierCapFloorEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BachelierCapFloorEngine > *)jarg1;
  arg1 = (BachelierCapFloorEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CliquetOption(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< PercentageStrikePayoff > *arg1 = 0 ;
  ext::shared_ptr< EuropeanExercise > *arg2 = 0 ;
  std::vector< Date > arg3 ;
  ext::shared_ptr< PercentageStrikePayoff > tempnull1 ;
  ext::shared_ptr< EuropeanExercise > tempnull2 ;
  std::vector< Date > *argp3 ;
  CliquetOption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< PercentageStrikePayoff > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< EuropeanExercise > *)jarg2 : &tempnull2; 
  argp3 = (std::vector< Date > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Date >", 0);
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (CliquetOption *)new CliquetOption((ext::shared_ptr< PercentageStrikePayoff > const &)*arg1,(ext::shared_ptr< EuropeanExercise > 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 ? new ext::shared_ptr<  CliquetOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CliquetOption(void * jarg1) {
  CliquetOption *arg1 = (CliquetOption *) 0 ;
  ext::shared_ptr< CliquetOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CliquetOption > *)jarg1;
  arg1 = (CliquetOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticCliquetEngine(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticCliquetEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticCliquetEngine *)new AnalyticCliquetEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticCliquetEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticCliquetEngine(void * jarg1) {
  AnalyticCliquetEngine *arg1 = (AnalyticCliquetEngine *) 0 ;
  ext::shared_ptr< AnalyticCliquetEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticCliquetEngine > *)jarg1;
  arg1 = (AnalyticCliquetEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticPerformanceEngine(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  AnalyticPerformanceEngine *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  {
    try {
      result = (AnalyticPerformanceEngine *)new AnalyticPerformanceEngine(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticPerformanceEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticPerformanceEngine(void * jarg1) {
  AnalyticPerformanceEngine *arg1 = (AnalyticPerformanceEngine *) 0 ;
  ext::shared_ptr< AnalyticPerformanceEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticPerformanceEngine > *)jarg1;
  arg1 = (AnalyticPerformanceEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRPerformanceEngine__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5, int jarg6, long jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  intOrNull arg6 ;
  BigInteger arg7 ;
  MCPerformanceEngine< PseudoRandom > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (BigInteger)jarg7; 
  {
    try {
      result = (MCPerformanceEngine< PseudoRandom > *)new_MCPerformanceEngine_Sl_PseudoRandom_Sg___SWIG_0(SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCPerformanceEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRPerformanceEngine__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  intOrNull arg6 ;
  MCPerformanceEngine< PseudoRandom > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCPerformanceEngine< PseudoRandom > *)new_MCPerformanceEngine_Sl_PseudoRandom_Sg___SWIG_0(SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCPerformanceEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRPerformanceEngine__SWIG_2(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  MCPerformanceEngine< PseudoRandom > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  {
    try {
      result = (MCPerformanceEngine< PseudoRandom > *)new_MCPerformanceEngine_Sl_PseudoRandom_Sg___SWIG_0(SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCPerformanceEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRPerformanceEngine__SWIG_3(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  MCPerformanceEngine< PseudoRandom > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  {
    try {
      result = (MCPerformanceEngine< PseudoRandom > *)new_MCPerformanceEngine_Sl_PseudoRandom_Sg___SWIG_0(SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCPerformanceEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRPerformanceEngine__SWIG_4(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  bool arg2 ;
  bool arg3 ;
  MCPerformanceEngine< PseudoRandom > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (MCPerformanceEngine< PseudoRandom > *)new_MCPerformanceEngine_Sl_PseudoRandom_Sg___SWIG_0(SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCPerformanceEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRPerformanceEngine__SWIG_5(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  bool arg2 ;
  MCPerformanceEngine< PseudoRandom > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MCPerformanceEngine< PseudoRandom > *)new_MCPerformanceEngine_Sl_PseudoRandom_Sg___SWIG_0(SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCPerformanceEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCPRPerformanceEngine__SWIG_6(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  MCPerformanceEngine< PseudoRandom > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  {
    try {
      result = (MCPerformanceEngine< PseudoRandom > *)new_MCPerformanceEngine_Sl_PseudoRandom_Sg___SWIG_0(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCPerformanceEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCPRPerformanceEngine(void * jarg1) {
  MCPerformanceEngine< PseudoRandom > *arg1 = (MCPerformanceEngine< PseudoRandom > *) 0 ;
  ext::shared_ptr< MCPerformanceEngine< PseudoRandom > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCPerformanceEngine<PseudoRandom> > *)jarg1;
  arg1 = (MCPerformanceEngine<PseudoRandom> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDPerformanceEngine__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5, int jarg6, long jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  intOrNull arg6 ;
  BigInteger arg7 ;
  MCPerformanceEngine< LowDiscrepancy > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (intOrNull)jarg6; 
  arg7 = (BigInteger)jarg7; 
  {
    try {
      result = (MCPerformanceEngine< LowDiscrepancy > *)new_MCPerformanceEngine_Sl_LowDiscrepancy_Sg___SWIG_0(SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCPerformanceEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDPerformanceEngine__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  intOrNull arg6 ;
  MCPerformanceEngine< LowDiscrepancy > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (intOrNull)jarg6; 
  {
    try {
      result = (MCPerformanceEngine< LowDiscrepancy > *)new_MCPerformanceEngine_Sl_LowDiscrepancy_Sg___SWIG_0(SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCPerformanceEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDPerformanceEngine__SWIG_2(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, double jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  doubleOrNull arg5 ;
  MCPerformanceEngine< LowDiscrepancy > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  {
    try {
      result = (MCPerformanceEngine< LowDiscrepancy > *)new_MCPerformanceEngine_Sl_LowDiscrepancy_Sg___SWIG_0(SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCPerformanceEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDPerformanceEngine__SWIG_3(void * jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  bool arg2 ;
  bool arg3 ;
  intOrNull arg4 ;
  MCPerformanceEngine< LowDiscrepancy > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  arg4 = (intOrNull)jarg4; 
  {
    try {
      result = (MCPerformanceEngine< LowDiscrepancy > *)new_MCPerformanceEngine_Sl_LowDiscrepancy_Sg___SWIG_0(SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCPerformanceEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDPerformanceEngine__SWIG_4(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  bool arg2 ;
  bool arg3 ;
  MCPerformanceEngine< LowDiscrepancy > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (MCPerformanceEngine< LowDiscrepancy > *)new_MCPerformanceEngine_Sl_LowDiscrepancy_Sg___SWIG_0(SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCPerformanceEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDPerformanceEngine__SWIG_5(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  bool arg2 ;
  MCPerformanceEngine< LowDiscrepancy > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (MCPerformanceEngine< LowDiscrepancy > *)new_MCPerformanceEngine_Sl_LowDiscrepancy_Sg___SWIG_0(SWIG_STD_MOVE(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 ? new ext::shared_ptr<  MCPerformanceEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MCLDPerformanceEngine__SWIG_6(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  MCPerformanceEngine< LowDiscrepancy > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  {
    try {
      result = (MCPerformanceEngine< LowDiscrepancy > *)new_MCPerformanceEngine_Sl_LowDiscrepancy_Sg___SWIG_0(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  MCPerformanceEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MCLDPerformanceEngine(void * jarg1) {
  MCPerformanceEngine< LowDiscrepancy > *arg1 = (MCPerformanceEngine< LowDiscrepancy > *) 0 ;
  ext::shared_ptr< MCPerformanceEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MCPerformanceEngine<LowDiscrepancy> > *)jarg1;
  arg1 = (MCPerformanceEngine<LowDiscrepancy> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, int jarg5, void * jarg6, void * jarg7, double jarg8) {
  void * jresult ;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  Real arg8 ;
  ext::shared_ptr< Exercise > tempnull1 ;
  ConvertibleZeroCouponBond *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Exercise > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (ConvertibleZeroCouponBond *)new ConvertibleZeroCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability > > const &)*arg3,(Date const &)*arg4,arg5,(DayCounter const &)*arg6,(Schedule 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 ? new ext::shared_ptr<  ConvertibleZeroCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleZeroCouponBond__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< Exercise > tempnull1 ;
  ConvertibleZeroCouponBond *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Exercise > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (Schedule *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConvertibleZeroCouponBond *)new ConvertibleZeroCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability > > const &)*arg3,(Date const &)*arg4,arg5,(DayCounter const &)*arg6,(Schedule 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 ? new ext::shared_ptr<  ConvertibleZeroCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ConvertibleZeroCouponBond(void * jarg1) {
  ConvertibleZeroCouponBond *arg1 = (ConvertibleZeroCouponBond *) 0 ;
  ext::shared_ptr< ConvertibleZeroCouponBond > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ConvertibleZeroCouponBond > *)jarg1;
  arg1 = (ConvertibleZeroCouponBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, int jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, void * jarg10, void * jarg11, int jarg12, unsigned int jarg13) {
  void * jresult ;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  std::vector< Rate > *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Schedule *arg8 = 0 ;
  Real arg9 ;
  Period *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  BusinessDayConvention arg12 ;
  bool arg13 ;
  ext::shared_ptr< Exercise > tempnull1 ;
  ConvertibleFixedCouponBond *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Exercise > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (std::vector< Rate > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg12 = (BusinessDayConvention)jarg12; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability > > const &)*arg3,(Date const &)*arg4,arg5,(std::vector< Rate > const &)*arg6,(DayCounter const &)*arg7,(Schedule const &)*arg8,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 = result ? new ext::shared_ptr<  ConvertibleFixedCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleFixedCouponBond__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, void * jarg10, void * jarg11, int jarg12) {
  void * jresult ;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  std::vector< Rate > *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Schedule *arg8 = 0 ;
  Real arg9 ;
  Period *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  BusinessDayConvention arg12 ;
  ext::shared_ptr< Exercise > tempnull1 ;
  ConvertibleFixedCouponBond *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Exercise > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (std::vector< Rate > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg12 = (BusinessDayConvention)jarg12; 
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability > > const &)*arg3,(Date const &)*arg4,arg5,(std::vector< Rate > const &)*arg6,(DayCounter const &)*arg7,(Schedule const &)*arg8,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 = result ? new ext::shared_ptr<  ConvertibleFixedCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleFixedCouponBond__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  std::vector< Rate > *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Schedule *arg8 = 0 ;
  Real arg9 ;
  Period *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  ext::shared_ptr< Exercise > tempnull1 ;
  ConvertibleFixedCouponBond *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Exercise > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (std::vector< Rate > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability > > const &)*arg3,(Date const &)*arg4,arg5,(std::vector< Rate > const &)*arg6,(DayCounter const &)*arg7,(Schedule const &)*arg8,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 = result ? new ext::shared_ptr<  ConvertibleFixedCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleFixedCouponBond__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9, void * jarg10) {
  void * jresult ;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  std::vector< Rate > *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Schedule *arg8 = 0 ;
  Real arg9 ;
  Period *arg10 = 0 ;
  ext::shared_ptr< Exercise > tempnull1 ;
  ConvertibleFixedCouponBond *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Exercise > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (std::vector< Rate > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Period *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability > > const &)*arg3,(Date const &)*arg4,arg5,(std::vector< Rate > const &)*arg6,(DayCounter const &)*arg7,(Schedule const &)*arg8,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 = result ? new ext::shared_ptr<  ConvertibleFixedCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleFixedCouponBond__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8, double jarg9) {
  void * jresult ;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  std::vector< Rate > *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Schedule *arg8 = 0 ;
  Real arg9 ;
  ext::shared_ptr< Exercise > tempnull1 ;
  ConvertibleFixedCouponBond *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Exercise > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (std::vector< Rate > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability > > const &)*arg3,(Date const &)*arg4,arg5,(std::vector< Rate > const &)*arg6,(DayCounter const &)*arg7,(Schedule 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 = result ? new ext::shared_ptr<  ConvertibleFixedCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleFixedCouponBond__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  std::vector< Rate > *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Schedule *arg8 = 0 ;
  ext::shared_ptr< Exercise > tempnull1 ;
  ConvertibleFixedCouponBond *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Exercise > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = (std::vector< Rate > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Schedule *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability > > const &)*arg3,(Date const &)*arg4,arg5,(std::vector< Rate > const &)*arg6,(DayCounter const &)*arg7,(Schedule 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 ? new ext::shared_ptr<  ConvertibleFixedCouponBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ConvertibleFixedCouponBond(void * jarg1) {
  ConvertibleFixedCouponBond *arg1 = (ConvertibleFixedCouponBond *) 0 ;
  ext::shared_ptr< ConvertibleFixedCouponBond > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ConvertibleFixedCouponBond > *)jarg1;
  arg1 = (ConvertibleFixedCouponBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, int jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, double jarg11, void * jarg12, void * jarg13, int jarg14, unsigned int jarg15) {
  void * jresult ;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Spread > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  Schedule *arg10 = 0 ;
  Real arg11 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  bool arg15 ;
  ext::shared_ptr< Exercise > tempnull1 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  ConvertibleFloatingRateBond *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Exercise > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Schedule *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg11 = (Real)jarg11; 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability > > const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,(std::vector< Spread > const &)*arg8,(DayCounter const &)*arg9,(Schedule const &)*arg10,arg11,(Period const &)*arg12,(Calendar const &)*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 = result ? new ext::shared_ptr<  ConvertibleFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleFloatingRateBond__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, double jarg11, void * jarg12, void * jarg13, int jarg14) {
  void * jresult ;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Spread > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  Schedule *arg10 = 0 ;
  Real arg11 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  ext::shared_ptr< Exercise > tempnull1 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  ConvertibleFloatingRateBond *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Exercise > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Schedule *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg11 = (Real)jarg11; 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg14 = (BusinessDayConvention)jarg14; 
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability > > const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,(std::vector< Spread > const &)*arg8,(DayCounter const &)*arg9,(Schedule const &)*arg10,arg11,(Period const &)*arg12,(Calendar 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 = result ? new ext::shared_ptr<  ConvertibleFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleFloatingRateBond__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, double jarg11, void * jarg12, void * jarg13) {
  void * jresult ;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Spread > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  Schedule *arg10 = 0 ;
  Real arg11 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  ext::shared_ptr< Exercise > tempnull1 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  ConvertibleFloatingRateBond *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Exercise > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Schedule *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg11 = (Real)jarg11; 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Calendar *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability > > const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,(std::vector< Spread > const &)*arg8,(DayCounter const &)*arg9,(Schedule const &)*arg10,arg11,(Period 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 = result ? new ext::shared_ptr<  ConvertibleFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleFloatingRateBond__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, double jarg11, void * jarg12) {
  void * jresult ;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Spread > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  Schedule *arg10 = 0 ;
  Real arg11 ;
  Period *arg12 = 0 ;
  ext::shared_ptr< Exercise > tempnull1 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  ConvertibleFloatingRateBond *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Exercise > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Schedule *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg11 = (Real)jarg11; 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability > > const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,(std::vector< Spread > const &)*arg8,(DayCounter const &)*arg9,(Schedule const &)*arg10,arg11,(Period 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 = result ? new ext::shared_ptr<  ConvertibleFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleFloatingRateBond__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10, double jarg11) {
  void * jresult ;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Spread > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  Schedule *arg10 = 0 ;
  Real arg11 ;
  ext::shared_ptr< Exercise > tempnull1 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  ConvertibleFloatingRateBond *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Exercise > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Schedule *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg11 = (Real)jarg11; 
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability > > const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,(std::vector< Spread > 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 = result ? new ext::shared_ptr<  ConvertibleFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConvertibleFloatingRateBond__SWIG_5(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5, void * jarg6, int jarg7, void * jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Spread > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  Schedule *arg10 = 0 ;
  ext::shared_ptr< Exercise > tempnull1 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  ConvertibleFloatingRateBond *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Exercise > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Callability > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Callability > > const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Integer)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Integer)jarg7; 
  arg8 = (std::vector< Spread > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg9 = (DayCounter *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg10 = (Schedule *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability > > const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,(std::vector< Spread > 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 = result ? new ext::shared_ptr<  ConvertibleFloatingRateBond >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ConvertibleFloatingRateBond(void * jarg1) {
  ConvertibleFloatingRateBond *arg1 = (ConvertibleFloatingRateBond *) 0 ;
  ext::shared_ptr< ConvertibleFloatingRateBond > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ConvertibleFloatingRateBond > *)jarg1;
  arg1 = (ConvertibleFloatingRateBond *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialCRRConvertibleEngine__SWIG_0(void * jarg1, unsigned long jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Dividend > > *arg4 = 0 ;
  BinomialConvertibleEngine< CoxRossRubinstein > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< ext::shared_ptr< Dividend > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Dividend > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BinomialConvertibleEngine< CoxRossRubinstein > *)new BinomialConvertibleEngine< CoxRossRubinstein >(arg1,arg2,(Handle< Quote > const &)*arg3,(std::vector< ext::shared_ptr< Dividend > > 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 ? new ext::shared_ptr<  BinomialConvertibleEngine<CoxRossRubinstein> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialCRRConvertibleEngine__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  BinomialConvertibleEngine< CoxRossRubinstein > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BinomialConvertibleEngine< CoxRossRubinstein > *)new BinomialConvertibleEngine< CoxRossRubinstein >(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 = result ? new ext::shared_ptr<  BinomialConvertibleEngine<CoxRossRubinstein> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialCRRConvertibleEngine(void * jarg1) {
  BinomialConvertibleEngine< CoxRossRubinstein > *arg1 = (BinomialConvertibleEngine< CoxRossRubinstein > *) 0 ;
  ext::shared_ptr< BinomialConvertibleEngine< CoxRossRubinstein > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialConvertibleEngine<CoxRossRubinstein> > *)jarg1;
  arg1 = (BinomialConvertibleEngine<CoxRossRubinstein> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialJRConvertibleEngine__SWIG_0(void * jarg1, unsigned long jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Dividend > > *arg4 = 0 ;
  BinomialConvertibleEngine< JarrowRudd > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< ext::shared_ptr< Dividend > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Dividend > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BinomialConvertibleEngine< JarrowRudd > *)new BinomialConvertibleEngine< JarrowRudd >(arg1,arg2,(Handle< Quote > const &)*arg3,(std::vector< ext::shared_ptr< Dividend > > 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 ? new ext::shared_ptr<  BinomialConvertibleEngine<JarrowRudd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialJRConvertibleEngine__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  BinomialConvertibleEngine< JarrowRudd > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BinomialConvertibleEngine< JarrowRudd > *)new BinomialConvertibleEngine< JarrowRudd >(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 = result ? new ext::shared_ptr<  BinomialConvertibleEngine<JarrowRudd> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialJRConvertibleEngine(void * jarg1) {
  BinomialConvertibleEngine< JarrowRudd > *arg1 = (BinomialConvertibleEngine< JarrowRudd > *) 0 ;
  ext::shared_ptr< BinomialConvertibleEngine< JarrowRudd > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialConvertibleEngine<JarrowRudd> > *)jarg1;
  arg1 = (BinomialConvertibleEngine<JarrowRudd> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialEQPConvertibleEngine__SWIG_0(void * jarg1, unsigned long jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Dividend > > *arg4 = 0 ;
  BinomialConvertibleEngine< AdditiveEQPBinomialTree > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< ext::shared_ptr< Dividend > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Dividend > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BinomialConvertibleEngine< AdditiveEQPBinomialTree > *)new BinomialConvertibleEngine< AdditiveEQPBinomialTree >(arg1,arg2,(Handle< Quote > const &)*arg3,(std::vector< ext::shared_ptr< Dividend > > 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 ? new ext::shared_ptr<  BinomialConvertibleEngine<AdditiveEQPBinomialTree> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialEQPConvertibleEngine__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  BinomialConvertibleEngine< AdditiveEQPBinomialTree > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BinomialConvertibleEngine< AdditiveEQPBinomialTree > *)new BinomialConvertibleEngine< AdditiveEQPBinomialTree >(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 = result ? new ext::shared_ptr<  BinomialConvertibleEngine<AdditiveEQPBinomialTree> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialEQPConvertibleEngine(void * jarg1) {
  BinomialConvertibleEngine< AdditiveEQPBinomialTree > *arg1 = (BinomialConvertibleEngine< AdditiveEQPBinomialTree > *) 0 ;
  ext::shared_ptr< BinomialConvertibleEngine< AdditiveEQPBinomialTree > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialConvertibleEngine<AdditiveEQPBinomialTree> > *)jarg1;
  arg1 = (BinomialConvertibleEngine<AdditiveEQPBinomialTree> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialTrigeorgisConvertibleEngine__SWIG_0(void * jarg1, unsigned long jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Dividend > > *arg4 = 0 ;
  BinomialConvertibleEngine< Trigeorgis > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< ext::shared_ptr< Dividend > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Dividend > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BinomialConvertibleEngine< Trigeorgis > *)new BinomialConvertibleEngine< Trigeorgis >(arg1,arg2,(Handle< Quote > const &)*arg3,(std::vector< ext::shared_ptr< Dividend > > 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 ? new ext::shared_ptr<  BinomialConvertibleEngine<Trigeorgis> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialTrigeorgisConvertibleEngine__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  BinomialConvertibleEngine< Trigeorgis > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BinomialConvertibleEngine< Trigeorgis > *)new BinomialConvertibleEngine< Trigeorgis >(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 = result ? new ext::shared_ptr<  BinomialConvertibleEngine<Trigeorgis> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialTrigeorgisConvertibleEngine(void * jarg1) {
  BinomialConvertibleEngine< Trigeorgis > *arg1 = (BinomialConvertibleEngine< Trigeorgis > *) 0 ;
  ext::shared_ptr< BinomialConvertibleEngine< Trigeorgis > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialConvertibleEngine<Trigeorgis> > *)jarg1;
  arg1 = (BinomialConvertibleEngine<Trigeorgis> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialTianConvertibleEngine__SWIG_0(void * jarg1, unsigned long jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Dividend > > *arg4 = 0 ;
  BinomialConvertibleEngine< Tian > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< ext::shared_ptr< Dividend > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Dividend > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BinomialConvertibleEngine< Tian > *)new BinomialConvertibleEngine< Tian >(arg1,arg2,(Handle< Quote > const &)*arg3,(std::vector< ext::shared_ptr< Dividend > > 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 ? new ext::shared_ptr<  BinomialConvertibleEngine<Tian> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialTianConvertibleEngine__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  BinomialConvertibleEngine< Tian > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BinomialConvertibleEngine< Tian > *)new BinomialConvertibleEngine< Tian >(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 = result ? new ext::shared_ptr<  BinomialConvertibleEngine<Tian> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialTianConvertibleEngine(void * jarg1) {
  BinomialConvertibleEngine< Tian > *arg1 = (BinomialConvertibleEngine< Tian > *) 0 ;
  ext::shared_ptr< BinomialConvertibleEngine< Tian > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialConvertibleEngine<Tian> > *)jarg1;
  arg1 = (BinomialConvertibleEngine<Tian> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialLRConvertibleEngine__SWIG_0(void * jarg1, unsigned long jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Dividend > > *arg4 = 0 ;
  BinomialConvertibleEngine< LeisenReimer > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< ext::shared_ptr< Dividend > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Dividend > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BinomialConvertibleEngine< LeisenReimer > *)new BinomialConvertibleEngine< LeisenReimer >(arg1,arg2,(Handle< Quote > const &)*arg3,(std::vector< ext::shared_ptr< Dividend > > 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 ? new ext::shared_ptr<  BinomialConvertibleEngine<LeisenReimer> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialLRConvertibleEngine__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  BinomialConvertibleEngine< LeisenReimer > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BinomialConvertibleEngine< LeisenReimer > *)new BinomialConvertibleEngine< LeisenReimer >(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 = result ? new ext::shared_ptr<  BinomialConvertibleEngine<LeisenReimer> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialLRConvertibleEngine(void * jarg1) {
  BinomialConvertibleEngine< LeisenReimer > *arg1 = (BinomialConvertibleEngine< LeisenReimer > *) 0 ;
  ext::shared_ptr< BinomialConvertibleEngine< LeisenReimer > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialConvertibleEngine<LeisenReimer> > *)jarg1;
  arg1 = (BinomialConvertibleEngine<LeisenReimer> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialJ4ConvertibleEngine__SWIG_0(void * jarg1, unsigned long jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Dividend > > *arg4 = 0 ;
  BinomialConvertibleEngine< Joshi4 > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< ext::shared_ptr< Dividend > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Dividend > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BinomialConvertibleEngine< Joshi4 > *)new BinomialConvertibleEngine< Joshi4 >(arg1,arg2,(Handle< Quote > const &)*arg3,(std::vector< ext::shared_ptr< Dividend > > 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 ? new ext::shared_ptr<  BinomialConvertibleEngine<Joshi4> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BinomialJ4ConvertibleEngine__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  BinomialConvertibleEngine< Joshi4 > *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BinomialConvertibleEngine< Joshi4 > *)new BinomialConvertibleEngine< Joshi4 >(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 = result ? new ext::shared_ptr<  BinomialConvertibleEngine<Joshi4> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BinomialJ4ConvertibleEngine(void * jarg1) {
  BinomialConvertibleEngine< Joshi4 > *arg1 = (BinomialConvertibleEngine< Joshi4 > *) 0 ;
  ext::shared_ptr< BinomialConvertibleEngine< Joshi4 > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BinomialConvertibleEngine<Joshi4> > *)jarg1;
  arg1 = (BinomialConvertibleEngine<Joshi4> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Forward_settlementDate(void * jarg1) {
  void * jresult ;
  Forward *arg1 = (Forward *) 0 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const Forward > *)jarg1;
  arg1 = (Forward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Forward const *)arg1)->settlementDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Forward_isExpired(void * jarg1) {
  unsigned int jresult ;
  Forward *arg1 = (Forward *) 0 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const Forward > *)jarg1;
  arg1 = (Forward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((Forward const *)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_Forward_calendar(void * jarg1) {
  void * jresult ;
  Forward *arg1 = (Forward *) 0 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  Calendar *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const Forward > *)jarg1;
  arg1 = (Forward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Calendar *) &((Forward const *)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 = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Forward_businessDayConvention(void * jarg1) {
  int jresult ;
  Forward *arg1 = (Forward *) 0 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  BusinessDayConvention result;
  
  
  smartarg1 = (ext::shared_ptr< const Forward > *)jarg1;
  arg1 = (Forward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (BusinessDayConvention)((Forward const *)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_Forward_dayCounter(void * jarg1) {
  void * jresult ;
  Forward *arg1 = (Forward *) 0 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  DayCounter *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const Forward > *)jarg1;
  arg1 = (Forward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (DayCounter *) &((Forward 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Forward_discountCurve(void * jarg1) {
  void * jresult ;
  Forward *arg1 = (Forward *) 0 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  Handle< YieldTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr< const Forward > *)jarg1;
  arg1 = (Forward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Forward const *)arg1)->discountCurve();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Forward_incomeDiscountCurve(void * jarg1) {
  void * jresult ;
  Forward *arg1 = (Forward *) 0 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  Handle< YieldTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr< const Forward > *)jarg1;
  arg1 = (Forward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Forward const *)arg1)->incomeDiscountCurve();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Forward_spotValue(void * jarg1) {
  double jresult ;
  Forward *arg1 = (Forward *) 0 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Forward > *)jarg1;
  arg1 = (Forward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((Forward const *)arg1)->spotValue();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Forward_spotIncome(void * jarg1, void * jarg2) {
  double jresult ;
  Forward *arg1 = (Forward *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Forward > *)jarg1;
  arg1 = (Forward *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Forward const *)arg1)->spotIncome((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_Forward_forwardValue(void * jarg1) {
  double jresult ;
  Forward *arg1 = (Forward *) 0 ;
  ext::shared_ptr< Forward > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Forward > *)jarg1;
  arg1 = (Forward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->forwardValue();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  Forward *arg1 = (Forward *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Date arg4 ;
  Compounding arg5 ;
  SwigValueWrapper< DayCounter > arg6 ;
  ext::shared_ptr< Forward > *smartarg1 = 0 ;
  Date *argp4 ;
  DayCounter *argp6 ;
  InterestRate result;
  
  
  smartarg1 = (ext::shared_ptr<  Forward > *)jarg1;
  arg1 = (Forward *)(smartarg1 ? smartarg1->get() : 0); 
  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 = (arg1)->impliedYield(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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Forward(void * jarg1) {
  Forward *arg1 = (Forward *) 0 ;
  ext::shared_ptr< Forward > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Forward > *)jarg1;
  arg1 = (Forward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BondForward__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 ;
  ext::shared_ptr< Bond > *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  ext::shared_ptr< Bond > tempnull9 ;
  BondForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg7 = (Calendar *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = jarg9 ? (ext::shared_ptr< Bond > *)jarg9 : &tempnull9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BondForward *)new BondForward((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,arg8,(ext::shared_ptr< Bond > 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 = result ? new ext::shared_ptr<  BondForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BondForward__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 ;
  ext::shared_ptr< Bond > *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  ext::shared_ptr< Bond > tempnull9 ;
  BondForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg7 = (Calendar *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = jarg9 ? (ext::shared_ptr< Bond > *)jarg9 : &tempnull9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BondForward *)new BondForward((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,arg8,(ext::shared_ptr< Bond > 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 = result ? new ext::shared_ptr<  BondForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BondForward__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 ;
  ext::shared_ptr< Bond > *arg9 = 0 ;
  ext::shared_ptr< Bond > tempnull9 ;
  BondForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg7 = (Calendar *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = jarg9 ? (ext::shared_ptr< Bond > *)jarg9 : &tempnull9; 
  {
    try {
      result = (BondForward *)new BondForward((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,arg8,(ext::shared_ptr< Bond > 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 ? new ext::shared_ptr<  BondForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondForward_forwardPrice(void * jarg1) {
  double jresult ;
  BondForward *arg1 = (BondForward *) 0 ;
  ext::shared_ptr< BondForward > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  BondForward > *)jarg1;
  arg1 = (BondForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->forwardPrice();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BondForward_cleanForwardPrice(void * jarg1) {
  double jresult ;
  BondForward *arg1 = (BondForward *) 0 ;
  ext::shared_ptr< BondForward > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  BondForward > *)jarg1;
  arg1 = (BondForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->cleanForwardPrice();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_BondForward(void * jarg1) {
  BondForward *arg1 = (BondForward *) 0 ;
  ext::shared_ptr< BondForward > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BondForward > *)jarg1;
  arg1 = (BondForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< FixedRateBond > *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  ext::shared_ptr< FixedRateBond > tempnull9 ;
  FixedRateBondForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg7 = (Calendar *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = jarg9 ? (ext::shared_ptr< FixedRateBond > *)jarg9 : &tempnull9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondForward *)new FixedRateBondForward((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,arg8,(ext::shared_ptr< FixedRateBond > 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 = result ? new ext::shared_ptr<  FixedRateBondForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< FixedRateBond > *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  ext::shared_ptr< FixedRateBond > tempnull9 ;
  FixedRateBondForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg7 = (Calendar *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = jarg9 ? (ext::shared_ptr< FixedRateBond > *)jarg9 : &tempnull9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondForward *)new FixedRateBondForward((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,arg8,(ext::shared_ptr< FixedRateBond > 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 = result ? new ext::shared_ptr<  FixedRateBondForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< FixedRateBond > *arg9 = 0 ;
  ext::shared_ptr< FixedRateBond > tempnull9 ;
  FixedRateBondForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg7 = (Calendar *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = jarg9 ? (ext::shared_ptr< FixedRateBond > *)jarg9 : &tempnull9; 
  {
    try {
      result = (FixedRateBondForward *)new FixedRateBondForward((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,arg8,(ext::shared_ptr< FixedRateBond > 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 ? new ext::shared_ptr<  FixedRateBondForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FixedRateBondForward(void * jarg1) {
  FixedRateBondForward *arg1 = (FixedRateBondForward *) 0 ;
  ext::shared_ptr< FixedRateBondForward > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FixedRateBondForward > *)jarg1;
  arg1 = (FixedRateBondForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_OvernightIndexFuture__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  ext::shared_ptr< OvernightIndex > arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Handle< Quote > arg4 ;
  RateAveraging::Type arg5 ;
  Handle< Quote > *argp4 ;
  OvernightIndexFuture *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< OvernightIndex > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  argp4 = (Handle< Quote > *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (RateAveraging::Type)jarg5; 
  {
    try {
      result = (OvernightIndexFuture *)new OvernightIndexFuture(arg1,(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 ? new ext::shared_ptr<  OvernightIndexFuture >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexFuture__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< OvernightIndex > arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Handle< Quote > arg4 ;
  Handle< Quote > *argp4 ;
  OvernightIndexFuture *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< OvernightIndex > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  argp4 = (Handle< Quote > *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg4 = *argp4; 
  {
    try {
      result = (OvernightIndexFuture *)new OvernightIndexFuture(arg1,(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 ? new ext::shared_ptr<  OvernightIndexFuture >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexFuture__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< OvernightIndex > arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  OvernightIndexFuture *result = 0 ;
  
  if (jarg1) arg1 = *(ext::shared_ptr< OvernightIndex > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (OvernightIndexFuture *)new OvernightIndexFuture(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 = result ? new ext::shared_ptr<  OvernightIndexFuture >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_OvernightIndexFuture_convexityAdjustment(void * jarg1) {
  double jresult ;
  OvernightIndexFuture *arg1 = (OvernightIndexFuture *) 0 ;
  ext::shared_ptr< OvernightIndexFuture const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const OvernightIndexFuture > *)jarg1;
  arg1 = (OvernightIndexFuture *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((OvernightIndexFuture const *)arg1)->convexityAdjustment();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_OvernightIndexFuture(void * jarg1) {
  OvernightIndexFuture *arg1 = (OvernightIndexFuture *) 0 ;
  ext::shared_ptr< OvernightIndexFuture > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexFuture > *)jarg1;
  arg1 = (OvernightIndexFuture *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_quote(void * jarg1) {
  void * jresult ;
  RateHelper *arg1 = (RateHelper *) 0 ;
  ext::shared_ptr< RateHelper const > *smartarg1 = 0 ;
  Handle< Quote > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const RateHelper > *)jarg1;
  arg1 = (RateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Handle< Quote > *) &((RateHelper const *)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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RateHelper_latestDate(void * jarg1) {
  void * jresult ;
  RateHelper *arg1 = (RateHelper *) 0 ;
  ext::shared_ptr< RateHelper const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const RateHelper > *)jarg1;
  arg1 = (RateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((RateHelper const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RateHelper_earliestDate(void * jarg1) {
  void * jresult ;
  RateHelper *arg1 = (RateHelper *) 0 ;
  ext::shared_ptr< RateHelper const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const RateHelper > *)jarg1;
  arg1 = (RateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((RateHelper const *)arg1)->earliestDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RateHelper_maturityDate(void * jarg1) {
  void * jresult ;
  RateHelper *arg1 = (RateHelper *) 0 ;
  ext::shared_ptr< RateHelper const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const RateHelper > *)jarg1;
  arg1 = (RateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((RateHelper const *)arg1)->maturityDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RateHelper_latestRelevantDate(void * jarg1) {
  void * jresult ;
  RateHelper *arg1 = (RateHelper *) 0 ;
  ext::shared_ptr< RateHelper const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const RateHelper > *)jarg1;
  arg1 = (RateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((RateHelper const *)arg1)->latestRelevantDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RateHelper_pillarDate(void * jarg1) {
  void * jresult ;
  RateHelper *arg1 = (RateHelper *) 0 ;
  ext::shared_ptr< RateHelper const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const RateHelper > *)jarg1;
  arg1 = (RateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((RateHelper const *)arg1)->pillarDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_RateHelper_impliedQuote(void * jarg1) {
  double jresult ;
  RateHelper *arg1 = (RateHelper *) 0 ;
  ext::shared_ptr< RateHelper const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const RateHelper > *)jarg1;
  arg1 = (RateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((RateHelper const *)arg1)->impliedQuote();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_RateHelper_quoteError(void * jarg1) {
  double jresult ;
  RateHelper *arg1 = (RateHelper *) 0 ;
  ext::shared_ptr< RateHelper const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const RateHelper > *)jarg1;
  arg1 = (RateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((RateHelper const *)arg1)->quoteError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_RateHelper(void * jarg1) {
  RateHelper *arg1 = (RateHelper *) 0 ;
  ext::shared_ptr< RateHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  RateHelper > *)jarg1;
  arg1 = (RateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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 ;
  DepositRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DepositRateHelper *)new DepositRateHelper((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 = result ? new ext::shared_ptr<  DepositRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  DepositRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DepositRateHelper *)new DepositRateHelper(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 = result ? new ext::shared_ptr<  DepositRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DepositRateHelper__SWIG_2(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< IborIndex > *arg2 = 0 ;
  ext::shared_ptr< IborIndex > tempnull2 ;
  DepositRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< IborIndex > *)jarg2 : &tempnull2; 
  {
    try {
      result = (DepositRateHelper *)new DepositRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< IborIndex > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  DepositRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DepositRateHelper__SWIG_3(double jarg1, void * jarg2) {
  void * jresult ;
  Rate arg1 ;
  ext::shared_ptr< IborIndex > *arg2 = 0 ;
  ext::shared_ptr< IborIndex > tempnull2 ;
  DepositRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< IborIndex > *)jarg2 : &tempnull2; 
  {
    try {
      result = (DepositRateHelper *)new DepositRateHelper(arg1,(ext::shared_ptr< IborIndex > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  DepositRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DepositRateHelper(void * jarg1) {
  DepositRateHelper *arg1 = (DepositRateHelper *) 0 ;
  ext::shared_ptr< DepositRateHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DepositRateHelper > *)jarg1;
  arg1 = (DepositRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, int jarg9, void * jarg10, unsigned int jarg11) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  Natural arg3 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  Pillar::Choice arg9 ;
  Date arg10 ;
  bool arg11 ;
  Date *argp10 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Pillar::Choice)jarg9; 
  argp10 = (Date *)jarg10; 
  if (!argp10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg10 = *argp10; 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter 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 = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8, int jarg9, void * jarg10) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  Natural arg3 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  Pillar::Choice arg9 ;
  Date arg10 ;
  Date *argp10 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Pillar::Choice)jarg9; 
  argp10 = (Date *)jarg10; 
  if (!argp10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg10 = *argp10; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter 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 = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_2(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8, int jarg9) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  Natural arg3 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  Pillar::Choice arg9 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Pillar::Choice)jarg9; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter 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 = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_3(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 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & 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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((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 = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_4(double jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8, int jarg9, void * jarg10, unsigned int jarg11) {
  void * jresult ;
  Rate arg1 ;
  Natural arg2 ;
  Natural arg3 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  Pillar::Choice arg9 ;
  Date arg10 ;
  bool arg11 ;
  Date *argp10 ;
  FraRateHelper *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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Pillar::Choice)jarg9; 
  argp10 = (Date *)jarg10; 
  if (!argp10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg10 = *argp10; 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,arg3,arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter 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 = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_5(double jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8, int jarg9, void * jarg10) {
  void * jresult ;
  Rate arg1 ;
  Natural arg2 ;
  Natural arg3 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  Pillar::Choice arg9 ;
  Date arg10 ;
  Date *argp10 ;
  FraRateHelper *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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Pillar::Choice)jarg9; 
  argp10 = (Date *)jarg10; 
  if (!argp10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg10 = *argp10; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,arg3,arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter 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 = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_6(double jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, void * jarg5, int jarg6, unsigned int jarg7, void * jarg8, int jarg9) {
  void * jresult ;
  Rate arg1 ;
  Natural arg2 ;
  Natural arg3 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  Pillar::Choice arg9 ;
  FraRateHelper *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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg9 = (Pillar::Choice)jarg9; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,arg3,arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter 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 = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_7(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 ;
  FraRateHelper *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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (DayCounter *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(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 = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_8(void * jarg1, unsigned int jarg2, void * jarg3, int jarg4, void * jarg5, unsigned int jarg6) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Date arg5 ;
  bool arg6 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Date *argp5 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Natural)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Pillar::Choice)jarg4; 
  argp5 = (Date *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg5 = *argp5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_9(void * jarg1, unsigned int jarg2, void * jarg3, int jarg4, void * jarg5) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Date arg5 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Date *argp5 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Natural)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Pillar::Choice)jarg4; 
  argp5 = (Date *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg5 = *argp5; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_10(void * jarg1, unsigned int jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Natural)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Pillar::Choice)jarg4; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_11(void * jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Natural)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_12(double jarg1, unsigned int jarg2, void * jarg3, int jarg4, void * jarg5, unsigned int jarg6) {
  void * jresult ;
  Rate arg1 ;
  Natural arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Date arg5 ;
  bool arg6 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Date *argp5 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Natural)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Pillar::Choice)jarg4; 
  argp5 = (Date *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg5 = *argp5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_13(double jarg1, unsigned int jarg2, void * jarg3, int jarg4, void * jarg5) {
  void * jresult ;
  Rate arg1 ;
  Natural arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Date arg5 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Date *argp5 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Natural)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Pillar::Choice)jarg4; 
  argp5 = (Date *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg5 = *argp5; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_14(double jarg1, unsigned int jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  Rate arg1 ;
  Natural arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Natural)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Pillar::Choice)jarg4; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_15(double jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  Rate arg1 ;
  Natural arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Natural)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_16(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4, int jarg5, void * jarg6, unsigned int jarg7) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  Natural arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Pillar::Choice arg5 ;
  Date arg6 ;
  bool arg7 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  Date *argp6 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Natural)jarg2; 
  arg3 = (Natural)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Pillar::Choice)jarg5; 
  argp6 = (Date *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg6 = *argp6; 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_17(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  Natural arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Pillar::Choice arg5 ;
  Date arg6 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  Date *argp6 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Natural)jarg2; 
  arg3 = (Natural)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Pillar::Choice)jarg5; 
  argp6 = (Date *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg6 = *argp6; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_18(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  Natural arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Pillar::Choice arg5 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Natural)jarg2; 
  arg3 = (Natural)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Pillar::Choice)jarg5; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_19(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  Natural arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Natural)jarg2; 
  arg3 = (Natural)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_20(double jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4, int jarg5, void * jarg6, unsigned int jarg7) {
  void * jresult ;
  Rate arg1 ;
  Natural arg2 ;
  Natural arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Pillar::Choice arg5 ;
  Date arg6 ;
  bool arg7 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  Date *argp6 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Natural)jarg2; 
  arg3 = (Natural)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Pillar::Choice)jarg5; 
  argp6 = (Date *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg6 = *argp6; 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,arg3,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_21(double jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4, int jarg5, void * jarg6) {
  void * jresult ;
  Rate arg1 ;
  Natural arg2 ;
  Natural arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Pillar::Choice arg5 ;
  Date arg6 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  Date *argp6 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Natural)jarg2; 
  arg3 = (Natural)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Pillar::Choice)jarg5; 
  argp6 = (Date *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg6 = *argp6; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,arg3,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_22(double jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  Rate arg1 ;
  Natural arg2 ;
  Natural arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Pillar::Choice arg5 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Natural)jarg2; 
  arg3 = (Natural)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  arg5 = (Pillar::Choice)jarg5; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,arg3,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_23(double jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
  void * jresult ;
  Rate arg1 ;
  Natural arg2 ;
  Natural arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  ext::shared_ptr< IborIndex > tempnull4 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Natural)jarg2; 
  arg3 = (Natural)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< IborIndex > *)jarg4 : &tempnull4; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,arg3,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_24(double jarg1, void * jarg2, void * jarg3, int jarg4, void * jarg5, unsigned int jarg6) {
  void * jresult ;
  Rate arg1 ;
  Period arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Date arg5 ;
  bool arg6 ;
  Period *argp2 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Date *argp5 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  argp2 = (Period *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Period", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Pillar::Choice)jarg4; 
  argp5 = (Date *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg5 = *argp5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_25(double jarg1, void * jarg2, void * jarg3, int jarg4, void * jarg5) {
  void * jresult ;
  Rate arg1 ;
  Period arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Date arg5 ;
  Period *argp2 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Date *argp5 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  argp2 = (Period *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Period", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Pillar::Choice)jarg4; 
  argp5 = (Date *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg5 = *argp5; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_26(double jarg1, void * jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  Rate arg1 ;
  Period arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Period *argp2 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  argp2 = (Period *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Period", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Pillar::Choice)jarg4; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_27(double jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Rate arg1 ;
  Period arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Period *argp2 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  argp2 = (Period *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Period", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_28(void * jarg1, void * jarg2, void * jarg3, int jarg4, void * jarg5, unsigned int jarg6) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Date arg5 ;
  bool arg6 ;
  Period *argp2 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Date *argp5 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  argp2 = (Period *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Period", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Pillar::Choice)jarg4; 
  argp5 = (Date *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg5 = *argp5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_29(void * jarg1, void * jarg2, void * jarg3, int jarg4, void * jarg5) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Date arg5 ;
  Period *argp2 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  Date *argp5 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  argp2 = (Period *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Period", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Pillar::Choice)jarg4; 
  argp5 = (Date *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg5 = *argp5; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_30(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Period *argp2 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  argp2 = (Period *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Period", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Pillar::Choice)jarg4; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FraRateHelper__SWIG_31(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Period *argp2 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  FraRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  argp2 = (Period *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Period", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FraRateHelper(void * jarg1) {
  FraRateHelper *arg1 = (FraRateHelper *) 0 ;
  ext::shared_ptr< FraRateHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FraRateHelper > *)jarg1;
  arg1 = (FraRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg9 = (Futures::Type)jarg9; 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((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 = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((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 = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_2(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6, void * jarg7) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((Handle< Quote > const &)*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 = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, 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 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Rate)jarg8; 
  arg9 = (Futures::Type)jarg9; 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(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 = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, double jarg8) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = (Rate)jarg8; 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(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 = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_5(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 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(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 = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_6(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 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (Futures::Type)jarg6; 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((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 = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_7(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 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((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 = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_8(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((Handle< Quote > const &)*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 = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_9(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 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Rate)jarg5; 
  arg6 = (Futures::Type)jarg6; 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(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 = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_10(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 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Rate)jarg5; 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(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 = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_11(double jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(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 = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_12(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Futures::Type arg5 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (Futures::Type)jarg5; 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_13(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_14(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_15(double jarg1, void * jarg2, void * jarg3, double jarg4, int jarg5) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Real arg4 ;
  Futures::Type arg5 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Futures::Type)jarg5; 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(arg1,(Date const &)*arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_16(double jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(arg1,(Date const &)*arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FuturesRateHelper__SWIG_17(double jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Real arg1 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > tempnull3 ;
  FuturesRateHelper *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< IborIndex > *)jarg3 : &tempnull3; 
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(arg1,(Date const &)*arg2,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FuturesRateHelper(void * jarg1) {
  FuturesRateHelper *arg1 = (FuturesRateHelper *) 0 ;
  ext::shared_ptr< FuturesRateHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FuturesRateHelper > *)jarg1;
  arg1 = (FuturesRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, unsigned int jarg14, void * jarg15) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  Date arg13 ;
  bool arg14 ;
  SwigValueWrapper< ext::optional< bool > > arg15 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  Date *argp13 ;
  ext::optional< bool > *argp15 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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; 
  arg14 = jarg14 ? true : false; 
  argp15 = (ext::optional< bool > *)jarg15; 
  if (!argp15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg15 = *argp15; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg13, unsigned int jarg14) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  Date arg13 ;
  bool arg14 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  Date *argp13 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, int jarg12, void * jarg13) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  Date arg13 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  Date *argp13 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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 = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, unsigned int jarg11, int jarg12) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = (Natural)jarg11; 
  arg12 = (Pillar::Choice)jarg12; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg10, unsigned int jarg11) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = (Natural)jarg11; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg9, void * jarg10) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg8, void * jarg9) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_7(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 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_8(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 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, int jarg12, void * jarg13, unsigned int jarg14, void * jarg15) {
  void * jresult ;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  Date arg13 ;
  bool arg14 ;
  SwigValueWrapper< ext::optional< bool > > arg15 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  Date *argp13 ;
  ext::optional< bool > *argp15 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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; 
  arg14 = jarg14 ? true : false; 
  argp15 = (ext::optional< bool > *)jarg15; 
  if (!argp15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg15 = *argp15; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, unsigned int jarg11, int jarg12, void * jarg13, unsigned int jarg14) {
  void * jresult ;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  Date arg13 ;
  bool arg14 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  Date *argp13 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * 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 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  Date arg13 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  Date *argp13 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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 = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * 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 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = (Natural)jarg11; 
  arg12 = (Pillar::Choice)jarg12; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * 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 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = (Natural)jarg11; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_14(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 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_15(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 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg9 = (Period *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_16(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 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (Handle< Quote > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_17(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 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Calendar *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg4 = (Frequency)jarg4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_18(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, unsigned int jarg8, void * jarg9) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  Date arg7 ;
  bool arg8 ;
  SwigValueWrapper< ext::optional< bool > > arg9 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  Date *argp7 ;
  ext::optional< bool > *argp9 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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; 
  arg8 = jarg8 ? true : false; 
  argp9 = (ext::optional< bool > *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg9 = *argp9; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3,(Period 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_19(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, unsigned int jarg8) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  Date arg7 ;
  bool arg8 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  Date *argp7 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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; 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3,(Period 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_20(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  Date arg7 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  Date *argp7 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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 = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_21(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = (Pillar::Choice)jarg6; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_22(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_23(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_24(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_25(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_26(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, unsigned int jarg8, void * jarg9) {
  void * jresult ;
  Rate arg1 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  Date arg7 ;
  bool arg8 ;
  SwigValueWrapper< ext::optional< bool > > arg9 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  Date *argp7 ;
  ext::optional< bool > *argp9 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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; 
  arg8 = jarg8 ? true : false; 
  argp9 = (ext::optional< bool > *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg9 = *argp9; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3,(Period 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_27(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, unsigned int jarg8) {
  void * jresult ;
  Rate arg1 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  Date arg7 ;
  bool arg8 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  Date *argp7 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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; 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3,(Period 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_28(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7) {
  void * jresult ;
  Rate arg1 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  Date arg7 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  Date *argp7 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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 = (SwapRateHelper *)new SwapRateHelper(arg1,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_29(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Rate arg1 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = (Pillar::Choice)jarg6; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_30(double jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Rate arg1 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_31(double jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Rate arg1 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (Period *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_32(double jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Rate arg1 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(ext::shared_ptr< SwapIndex > 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 = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SwapRateHelper__SWIG_33(double jarg1, void * jarg2) {
  void * jresult ;
  Rate arg1 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull2 ;
  SwapRateHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< SwapIndex > *)jarg2 : &tempnull2; 
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(ext::shared_ptr< SwapIndex > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SwapRateHelper_spread(void * jarg1) {
  double jresult ;
  SwapRateHelper *arg1 = (SwapRateHelper *) 0 ;
  ext::shared_ptr< SwapRateHelper > *smartarg1 = 0 ;
  Spread result;
  
  
  smartarg1 = (ext::shared_ptr<  SwapRateHelper > *)jarg1;
  arg1 = (SwapRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Spread)(arg1)->spread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SwapRateHelper_swap(void * jarg1) {
  void * jresult ;
  SwapRateHelper *arg1 = (SwapRateHelper *) 0 ;
  ext::shared_ptr< SwapRateHelper > *smartarg1 = 0 ;
  ext::shared_ptr< VanillaSwap > result;
  
  
  smartarg1 = (ext::shared_ptr<  SwapRateHelper > *)jarg1;
  arg1 = (SwapRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->swap();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< VanillaSwap >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SwapRateHelper(void * jarg1) {
  SwapRateHelper *arg1 = (SwapRateHelper *) 0 ;
  ext::shared_ptr< SwapRateHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SwapRateHelper > *)jarg1;
  arg1 = (SwapRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, int jarg3) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< Bond > *arg2 = 0 ;
  BondPrice::Type arg3 ;
  ext::shared_ptr< Bond > tempnull2 ;
  BondHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< Bond > *)jarg2 : &tempnull2; 
  arg3 = (BondPrice::Type)jarg3; 
  {
    try {
      result = (BondHelper *)new BondHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< Bond > 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 ? new ext::shared_ptr<  BondHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BondHelper__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< Bond > *arg2 = 0 ;
  ext::shared_ptr< Bond > tempnull2 ;
  BondHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< Bond > *)jarg2 : &tempnull2; 
  {
    try {
      result = (BondHelper *)new BondHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< Bond > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  BondHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondHelper_bond(void * jarg1) {
  void * jresult ;
  BondHelper *arg1 = (BondHelper *) 0 ;
  ext::shared_ptr< BondHelper > *smartarg1 = 0 ;
  ext::shared_ptr< Bond > result;
  
  
  smartarg1 = (ext::shared_ptr<  BondHelper > *)jarg1;
  arg1 = (BondHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->bond();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< Bond >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BondHelper(void * jarg1) {
  BondHelper *arg1 = (BondHelper *) 0 ;
  ext::shared_ptr< BondHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BondHelper > *)jarg1;
  arg1 = (BondHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, 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 ;
  BondPrice::Type arg15 ;
  FixedRateBondHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg12 = (Calendar *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg13 = (BusinessDayConvention)jarg13; 
  arg14 = jarg14 ? true : false; 
  arg15 = (BondPrice::Type)jarg15; 
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBondHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg12 = (Calendar *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg13 = (BusinessDayConvention)jarg13; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBondHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg12 = (Calendar *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg13 = (BusinessDayConvention)jarg13; 
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBondHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg12 = (Calendar *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBondHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBondHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBondHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBondHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBondHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = (BusinessDayConvention)jarg7; 
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FixedRateBondHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FixedRateBondHelper_fixedRateBond(void * jarg1) {
  void * jresult ;
  FixedRateBondHelper *arg1 = (FixedRateBondHelper *) 0 ;
  ext::shared_ptr< FixedRateBondHelper > *smartarg1 = 0 ;
  ext::shared_ptr< FixedRateBond > result;
  
  
  smartarg1 = (ext::shared_ptr<  FixedRateBondHelper > *)jarg1;
  arg1 = (FixedRateBondHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->fixedRateBond();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< FixedRateBond >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FixedRateBondHelper(void * jarg1) {
  FixedRateBondHelper *arg1 = (FixedRateBondHelper *) 0 ;
  ext::shared_ptr< FixedRateBondHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FixedRateBondHelper > *)jarg1;
  arg1 = (FixedRateBondHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, int jarg7, int jarg8, int jarg9, void * jarg10, void * jarg11, double jarg12, int jarg13, void * jarg14, int jarg15, void * jarg16, void * jarg17, void * jarg18) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Integer arg7 ;
  BusinessDayConvention arg8 ;
  Frequency arg9 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  Spread arg12 ;
  Pillar::Choice arg13 ;
  Date arg14 ;
  RateAveraging::Type arg15 ;
  SwigValueWrapper< ext::optional< bool > > arg16 ;
  SwigValueWrapper< ext::optional< enum Frequency > > arg17 ;
  Calendar *arg18 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  Date *argp14 ;
  ext::optional< bool > *argp16 ;
  ext::optional< Frequency > *argp17 ;
  OISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Integer)jarg7; 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (Frequency)jarg9; 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg12 = (Spread)jarg12; 
  arg13 = (Pillar::Choice)jarg13; 
  argp14 = (Date *)jarg14; 
  if (!argp14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg14 = *argp14; 
  arg15 = (RateAveraging::Type)jarg15; 
  argp16 = (ext::optional< bool > *)jarg16; 
  if (!argp16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg16 = *argp16; 
  argp17 = (ext::optional< Frequency > *)jarg17; 
  if (!argp17) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< Frequency >", 0);
    return 0;
  }
  arg17 = *argp17; 
  arg18 = (Calendar *)jarg18;
  if (!arg18) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (OISRateHelper *)new OISRateHelper(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,(Calendar const &)*arg10,(Period const &)*arg11,arg12,arg13,arg14,arg15,arg16,arg17,(Calendar 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 = result ? new ext::shared_ptr<  OISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, int jarg7, int jarg8, int jarg9, void * jarg10, void * jarg11, double jarg12, int jarg13, void * jarg14, int jarg15, void * jarg16, void * jarg17) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Integer arg7 ;
  BusinessDayConvention arg8 ;
  Frequency arg9 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  Spread arg12 ;
  Pillar::Choice arg13 ;
  Date arg14 ;
  RateAveraging::Type arg15 ;
  SwigValueWrapper< ext::optional< bool > > arg16 ;
  SwigValueWrapper< ext::optional< enum Frequency > > arg17 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  Date *argp14 ;
  ext::optional< bool > *argp16 ;
  ext::optional< Frequency > *argp17 ;
  OISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Integer)jarg7; 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (Frequency)jarg9; 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg12 = (Spread)jarg12; 
  arg13 = (Pillar::Choice)jarg13; 
  argp14 = (Date *)jarg14; 
  if (!argp14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg14 = *argp14; 
  arg15 = (RateAveraging::Type)jarg15; 
  argp16 = (ext::optional< bool > *)jarg16; 
  if (!argp16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg16 = *argp16; 
  argp17 = (ext::optional< Frequency > *)jarg17; 
  if (!argp17) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< Frequency >", 0);
    return 0;
  }
  arg17 = *argp17; 
  {
    try {
      result = (OISRateHelper *)new OISRateHelper(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,(Calendar const &)*arg10,(Period const &)*arg11,arg12,arg13,arg14,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 = result ? new ext::shared_ptr<  OISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, int jarg7, int jarg8, int jarg9, void * jarg10, void * jarg11, double jarg12, int jarg13, void * jarg14, int jarg15, void * jarg16) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Integer arg7 ;
  BusinessDayConvention arg8 ;
  Frequency arg9 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  Spread arg12 ;
  Pillar::Choice arg13 ;
  Date arg14 ;
  RateAveraging::Type arg15 ;
  SwigValueWrapper< ext::optional< bool > > arg16 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  Date *argp14 ;
  ext::optional< bool > *argp16 ;
  OISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Integer)jarg7; 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (Frequency)jarg9; 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg12 = (Spread)jarg12; 
  arg13 = (Pillar::Choice)jarg13; 
  argp14 = (Date *)jarg14; 
  if (!argp14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg14 = *argp14; 
  arg15 = (RateAveraging::Type)jarg15; 
  argp16 = (ext::optional< bool > *)jarg16; 
  if (!argp16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg16 = *argp16; 
  {
    try {
      result = (OISRateHelper *)new OISRateHelper(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,(Calendar const &)*arg10,(Period const &)*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 = result ? new ext::shared_ptr<  OISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, int jarg7, int jarg8, int jarg9, void * jarg10, void * jarg11, double jarg12, int jarg13, void * jarg14, int jarg15) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Integer arg7 ;
  BusinessDayConvention arg8 ;
  Frequency arg9 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  Spread arg12 ;
  Pillar::Choice arg13 ;
  Date arg14 ;
  RateAveraging::Type arg15 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  Date *argp14 ;
  OISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Integer)jarg7; 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (Frequency)jarg9; 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg12 = (Spread)jarg12; 
  arg13 = (Pillar::Choice)jarg13; 
  argp14 = (Date *)jarg14; 
  if (!argp14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg14 = *argp14; 
  arg15 = (RateAveraging::Type)jarg15; 
  {
    try {
      result = (OISRateHelper *)new OISRateHelper(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,(Calendar const &)*arg10,(Period const &)*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 = result ? new ext::shared_ptr<  OISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, int jarg7, int jarg8, int jarg9, void * jarg10, void * jarg11, double jarg12, int jarg13, void * jarg14) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Integer arg7 ;
  BusinessDayConvention arg8 ;
  Frequency arg9 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  Spread arg12 ;
  Pillar::Choice arg13 ;
  Date arg14 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  Date *argp14 ;
  OISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Integer)jarg7; 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (Frequency)jarg9; 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg12 = (Spread)jarg12; 
  arg13 = (Pillar::Choice)jarg13; 
  argp14 = (Date *)jarg14; 
  if (!argp14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg14 = *argp14; 
  {
    try {
      result = (OISRateHelper *)new OISRateHelper(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,(Calendar const &)*arg10,(Period 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 = result ? new ext::shared_ptr<  OISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, int jarg7, int jarg8, int jarg9, void * jarg10, void * jarg11, double jarg12, int jarg13) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Integer arg7 ;
  BusinessDayConvention arg8 ;
  Frequency arg9 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  Spread arg12 ;
  Pillar::Choice arg13 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  OISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Integer)jarg7; 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (Frequency)jarg9; 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg12 = (Spread)jarg12; 
  arg13 = (Pillar::Choice)jarg13; 
  {
    try {
      result = (OISRateHelper *)new OISRateHelper(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,(Calendar const &)*arg10,(Period 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 = result ? new ext::shared_ptr<  OISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, int jarg7, int jarg8, int jarg9, void * jarg10, void * jarg11, double jarg12) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Integer arg7 ;
  BusinessDayConvention arg8 ;
  Frequency arg9 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  Spread arg12 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  OISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Integer)jarg7; 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (Frequency)jarg9; 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg12 = (Spread)jarg12; 
  {
    try {
      result = (OISRateHelper *)new OISRateHelper(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_7(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7, int jarg8, int jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Integer arg7 ;
  BusinessDayConvention arg8 ;
  Frequency arg9 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  OISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Integer)jarg7; 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (Frequency)jarg9; 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg11 = (Period *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (OISRateHelper *)new OISRateHelper(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_8(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7, int jarg8, int jarg9, void * jarg10) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Integer arg7 ;
  BusinessDayConvention arg8 ;
  Frequency arg9 ;
  Calendar *arg10 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  OISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Integer)jarg7; 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (Frequency)jarg9; 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (OISRateHelper *)new OISRateHelper(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_9(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7, int jarg8, int jarg9) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Integer arg7 ;
  BusinessDayConvention arg8 ;
  Frequency arg9 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  OISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Integer)jarg7; 
  arg8 = (BusinessDayConvention)jarg8; 
  arg9 = (Frequency)jarg9; 
  {
    try {
      result = (OISRateHelper *)new OISRateHelper(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_10(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7, int jarg8) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Integer arg7 ;
  BusinessDayConvention arg8 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  OISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Integer)jarg7; 
  arg8 = (BusinessDayConvention)jarg8; 
  {
    try {
      result = (OISRateHelper *)new OISRateHelper(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_11(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  Integer arg7 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  OISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Integer)jarg7; 
  {
    try {
      result = (OISRateHelper *)new OISRateHelper(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_12(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 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  OISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (OISRateHelper *)new OISRateHelper(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_13(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  OISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (OISRateHelper *)new OISRateHelper(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OISRateHelper__SWIG_14(unsigned int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  OISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  {
    try {
      result = (OISRateHelper *)new OISRateHelper(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 ? new ext::shared_ptr<  OISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OISRateHelper_swap(void * jarg1) {
  void * jresult ;
  OISRateHelper *arg1 = (OISRateHelper *) 0 ;
  ext::shared_ptr< OISRateHelper > *smartarg1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > result;
  
  
  smartarg1 = (ext::shared_ptr<  OISRateHelper > *)jarg1;
  arg1 = (OISRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->swap();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< OvernightIndexedSwap >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_OISRateHelper(void * jarg1) {
  OISRateHelper *arg1 = (OISRateHelper *) 0 ;
  ext::shared_ptr< OISRateHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OISRateHelper > *)jarg1;
  arg1 = (OISRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, unsigned int jarg6, int jarg7, int jarg8, int jarg9, int jarg10, void * jarg11, void * jarg12, double jarg13, void * jarg14, void * jarg15, void * jarg16) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  RateAveraging::Type arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  Frequency arg10 ;
  Calendar *arg11 = 0 ;
  Period *arg12 = 0 ;
  Spread arg13 ;
  SwigValueWrapper< ext::optional< bool > > arg14 ;
  SwigValueWrapper< ext::optional< enum Frequency > > arg15 ;
  Calendar *arg16 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  ext::optional< bool > *argp14 ;
  ext::optional< Frequency > *argp15 ;
  DatedOISRateHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (RateAveraging::Type)jarg7; 
  arg8 = (Integer)jarg8; 
  arg9 = (BusinessDayConvention)jarg9; 
  arg10 = (Frequency)jarg10; 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Spread)jarg13; 
  argp14 = (ext::optional< bool > *)jarg14; 
  if (!argp14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg14 = *argp14; 
  argp15 = (ext::optional< Frequency > *)jarg15; 
  if (!argp15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< Frequency >", 0);
    return 0;
  }
  arg15 = *argp15; 
  arg16 = (Calendar *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DatedOISRateHelper *)new DatedOISRateHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,arg10,(Calendar const &)*arg11,(Period const &)*arg12,arg13,arg14,arg15,(Calendar 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 = result ? new ext::shared_ptr<  DatedOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DatedOISRateHelper__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7, int jarg8, int jarg9, int jarg10, void * jarg11, void * jarg12, double jarg13, void * jarg14, void * jarg15) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  RateAveraging::Type arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  Frequency arg10 ;
  Calendar *arg11 = 0 ;
  Period *arg12 = 0 ;
  Spread arg13 ;
  SwigValueWrapper< ext::optional< bool > > arg14 ;
  SwigValueWrapper< ext::optional< enum Frequency > > arg15 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  ext::optional< bool > *argp14 ;
  ext::optional< Frequency > *argp15 ;
  DatedOISRateHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (RateAveraging::Type)jarg7; 
  arg8 = (Integer)jarg8; 
  arg9 = (BusinessDayConvention)jarg9; 
  arg10 = (Frequency)jarg10; 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Spread)jarg13; 
  argp14 = (ext::optional< bool > *)jarg14; 
  if (!argp14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg14 = *argp14; 
  argp15 = (ext::optional< Frequency > *)jarg15; 
  if (!argp15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< Frequency >", 0);
    return 0;
  }
  arg15 = *argp15; 
  {
    try {
      result = (DatedOISRateHelper *)new DatedOISRateHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,arg10,(Calendar const &)*arg11,(Period 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 = result ? new ext::shared_ptr<  DatedOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DatedOISRateHelper__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7, int jarg8, int jarg9, int jarg10, void * jarg11, void * jarg12, double jarg13, void * jarg14) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  RateAveraging::Type arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  Frequency arg10 ;
  Calendar *arg11 = 0 ;
  Period *arg12 = 0 ;
  Spread arg13 ;
  SwigValueWrapper< ext::optional< bool > > arg14 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  ext::optional< bool > *argp14 ;
  DatedOISRateHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (RateAveraging::Type)jarg7; 
  arg8 = (Integer)jarg8; 
  arg9 = (BusinessDayConvention)jarg9; 
  arg10 = (Frequency)jarg10; 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Spread)jarg13; 
  argp14 = (ext::optional< bool > *)jarg14; 
  if (!argp14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null ext::optional< bool >", 0);
    return 0;
  }
  arg14 = *argp14; 
  {
    try {
      result = (DatedOISRateHelper *)new DatedOISRateHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,arg10,(Calendar const &)*arg11,(Period 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 = result ? new ext::shared_ptr<  DatedOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DatedOISRateHelper__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7, int jarg8, int jarg9, int jarg10, void * jarg11, void * jarg12, double jarg13) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  RateAveraging::Type arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  Frequency arg10 ;
  Calendar *arg11 = 0 ;
  Period *arg12 = 0 ;
  Spread arg13 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  DatedOISRateHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (RateAveraging::Type)jarg7; 
  arg8 = (Integer)jarg8; 
  arg9 = (BusinessDayConvention)jarg9; 
  arg10 = (Frequency)jarg10; 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg13 = (Spread)jarg13; 
  {
    try {
      result = (DatedOISRateHelper *)new DatedOISRateHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,arg10,(Calendar const &)*arg11,(Period 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 = result ? new ext::shared_ptr<  DatedOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DatedOISRateHelper__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7, int jarg8, int jarg9, int jarg10, void * jarg11, void * jarg12) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  RateAveraging::Type arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  Frequency arg10 ;
  Calendar *arg11 = 0 ;
  Period *arg12 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  DatedOISRateHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (RateAveraging::Type)jarg7; 
  arg8 = (Integer)jarg8; 
  arg9 = (BusinessDayConvention)jarg9; 
  arg10 = (Frequency)jarg10; 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg12 = (Period *)jarg12;
  if (!arg12) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DatedOISRateHelper *)new DatedOISRateHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,arg10,(Calendar const &)*arg11,(Period 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 = result ? new ext::shared_ptr<  DatedOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DatedOISRateHelper__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7, int jarg8, int jarg9, int jarg10, void * jarg11) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  RateAveraging::Type arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  Frequency arg10 ;
  Calendar *arg11 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  DatedOISRateHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (RateAveraging::Type)jarg7; 
  arg8 = (Integer)jarg8; 
  arg9 = (BusinessDayConvention)jarg9; 
  arg10 = (Frequency)jarg10; 
  arg11 = (Calendar *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DatedOISRateHelper *)new DatedOISRateHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,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 = result ? new ext::shared_ptr<  DatedOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DatedOISRateHelper__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7, int jarg8, int jarg9, int jarg10) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  RateAveraging::Type arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  Frequency arg10 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  DatedOISRateHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (RateAveraging::Type)jarg7; 
  arg8 = (Integer)jarg8; 
  arg9 = (BusinessDayConvention)jarg9; 
  arg10 = (Frequency)jarg10; 
  {
    try {
      result = (DatedOISRateHelper *)new DatedOISRateHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< YieldTermStructure > const &)*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 ? new ext::shared_ptr<  DatedOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DatedOISRateHelper__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7, int jarg8, int jarg9) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  RateAveraging::Type arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  DatedOISRateHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (RateAveraging::Type)jarg7; 
  arg8 = (Integer)jarg8; 
  arg9 = (BusinessDayConvention)jarg9; 
  {
    try {
      result = (DatedOISRateHelper *)new DatedOISRateHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  DatedOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DatedOISRateHelper__SWIG_8(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7, int jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  RateAveraging::Type arg7 ;
  Integer arg8 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  DatedOISRateHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (RateAveraging::Type)jarg7; 
  arg8 = (Integer)jarg8; 
  {
    try {
      result = (DatedOISRateHelper *)new DatedOISRateHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  DatedOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DatedOISRateHelper__SWIG_9(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6, int jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  RateAveraging::Type arg7 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  DatedOISRateHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (RateAveraging::Type)jarg7; 
  {
    try {
      result = (DatedOISRateHelper *)new DatedOISRateHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  DatedOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DatedOISRateHelper__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned int jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  bool arg6 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  DatedOISRateHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (DatedOISRateHelper *)new DatedOISRateHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  DatedOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DatedOISRateHelper__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  DatedOISRateHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DatedOISRateHelper *)new DatedOISRateHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  DatedOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DatedOISRateHelper__SWIG_12(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  DatedOISRateHelper *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  {
    try {
      result = (DatedOISRateHelper *)new DatedOISRateHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 ? new ext::shared_ptr<  DatedOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DatedOISRateHelper(void * jarg1) {
  DatedOISRateHelper *arg1 = (DatedOISRateHelper *) 0 ;
  ext::shared_ptr< DatedOISRateHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DatedOISRateHelper > *)jarg1;
  arg1 = (DatedOISRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  FxSwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Natural)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Calendar *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FxSwapRateHelper *)new FxSwapRateHelper((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 = result ? new ext::shared_ptr<  FxSwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FxSwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Natural)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FxSwapRateHelper *)new FxSwapRateHelper((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 = result ? new ext::shared_ptr<  FxSwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FxSwapRateHelper(void * jarg1) {
  FxSwapRateHelper *arg1 = (FxSwapRateHelper *) 0 ;
  ext::shared_ptr< FxSwapRateHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FxSwapRateHelper > *)jarg1;
  arg1 = (FxSwapRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexFutureRateHelper__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  RateAveraging::Type arg6 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  OvernightIndexFutureRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg6 = (RateAveraging::Type)jarg6; 
  {
    try {
      result = (OvernightIndexFutureRateHelper *)new OvernightIndexFutureRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,(Date const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OvernightIndexFutureRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexFutureRateHelper__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  OvernightIndexFutureRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (OvernightIndexFutureRateHelper *)new OvernightIndexFutureRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,(Date const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 = result ? new ext::shared_ptr<  OvernightIndexFutureRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIndexFutureRateHelper__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > tempnull4 ;
  OvernightIndexFutureRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< OvernightIndex > *)jarg4 : &tempnull4; 
  {
    try {
      result = (OvernightIndexFutureRateHelper *)new OvernightIndexFutureRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,(Date const &)*arg3,(ext::shared_ptr< OvernightIndex > 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 ? new ext::shared_ptr<  OvernightIndexFutureRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_OvernightIndexFutureRateHelper(void * jarg1) {
  OvernightIndexFutureRateHelper *arg1 = (OvernightIndexFutureRateHelper *) 0 ;
  ext::shared_ptr< OvernightIndexFutureRateHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIndexFutureRateHelper > *)jarg1;
  arg1 = (OvernightIndexFutureRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SofrFutureRateHelper__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, void * jarg5) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Month arg2 ;
  Year arg3 ;
  Frequency arg4 ;
  Handle< Quote > *arg5 = 0 ;
  SofrFutureRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Month)jarg2; 
  arg3 = (Year)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Handle< Quote > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SofrFutureRateHelper *)new SofrFutureRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,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 = result ? new ext::shared_ptr<  SofrFutureRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SofrFutureRateHelper__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Month arg2 ;
  Year arg3 ;
  Frequency arg4 ;
  SofrFutureRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Month)jarg2; 
  arg3 = (Year)jarg3; 
  arg4 = (Frequency)jarg4; 
  {
    try {
      result = (SofrFutureRateHelper *)new SofrFutureRateHelper((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 = result ? new ext::shared_ptr<  SofrFutureRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SofrFutureRateHelper__SWIG_2(double jarg1, int jarg2, int jarg3, int jarg4, double jarg5) {
  void * jresult ;
  Real arg1 ;
  Month arg2 ;
  Year arg3 ;
  Frequency arg4 ;
  Real arg5 ;
  SofrFutureRateHelper *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Month)jarg2; 
  arg3 = (Year)jarg3; 
  arg4 = (Frequency)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (SofrFutureRateHelper *)new SofrFutureRateHelper(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 ? new ext::shared_ptr<  SofrFutureRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SofrFutureRateHelper__SWIG_3(double jarg1, int jarg2, int jarg3, int jarg4) {
  void * jresult ;
  Real arg1 ;
  Month arg2 ;
  Year arg3 ;
  Frequency arg4 ;
  SofrFutureRateHelper *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Month)jarg2; 
  arg3 = (Year)jarg3; 
  arg4 = (Frequency)jarg4; 
  {
    try {
      result = (SofrFutureRateHelper *)new SofrFutureRateHelper(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 ? new ext::shared_ptr<  SofrFutureRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SofrFutureRateHelper(void * jarg1) {
  SofrFutureRateHelper *arg1 = (SofrFutureRateHelper *) 0 ;
  ext::shared_ptr< SofrFutureRateHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SofrFutureRateHelper > *)jarg1;
  arg1 = (SofrFutureRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ConstNotionalCrossCurrencyBasisSwapRateHelper(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6, void * jarg7, void * jarg8, void * jarg9, unsigned int jarg10, unsigned int jarg11) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  SwigValueWrapper< Calendar > arg4 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  ext::shared_ptr< IborIndex > arg7 ;
  ext::shared_ptr< IborIndex > arg8 ;
  Handle< YieldTermStructure > arg9 ;
  bool arg10 ;
  bool arg11 ;
  Calendar *argp4 ;
  Handle< YieldTermStructure > *argp9 ;
  ConstNotionalCrossCurrencyBasisSwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  argp4 = (Calendar *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  if (jarg7) arg7 = *(ext::shared_ptr< IborIndex > *)jarg7; 
  if (jarg8) arg8 = *(ext::shared_ptr< IborIndex > *)jarg8; 
  argp9 = (Handle< YieldTermStructure > *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg9 = *argp9; 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (ConstNotionalCrossCurrencyBasisSwapRateHelper *)new ConstNotionalCrossCurrencyBasisSwapRateHelper((Handle< Quote > const &)*arg1,(Period 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 = result ? new ext::shared_ptr<  ConstNotionalCrossCurrencyBasisSwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ConstNotionalCrossCurrencyBasisSwapRateHelper(void * jarg1) {
  ConstNotionalCrossCurrencyBasisSwapRateHelper *arg1 = (ConstNotionalCrossCurrencyBasisSwapRateHelper *) 0 ;
  ext::shared_ptr< ConstNotionalCrossCurrencyBasisSwapRateHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ConstNotionalCrossCurrencyBasisSwapRateHelper > *)jarg1;
  arg1 = (ConstNotionalCrossCurrencyBasisSwapRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MtMCrossCurrencyBasisSwapRateHelper(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6, void * jarg7, void * jarg8, void * jarg9, unsigned int jarg10, unsigned int jarg11, unsigned int jarg12) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  SwigValueWrapper< Calendar > arg4 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  ext::shared_ptr< IborIndex > arg7 ;
  ext::shared_ptr< IborIndex > arg8 ;
  Handle< YieldTermStructure > arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  Calendar *argp4 ;
  Handle< YieldTermStructure > *argp9 ;
  MtMCrossCurrencyBasisSwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  argp4 = (Calendar *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  if (jarg7) arg7 = *(ext::shared_ptr< IborIndex > *)jarg7; 
  if (jarg8) arg8 = *(ext::shared_ptr< IborIndex > *)jarg8; 
  argp9 = (Handle< YieldTermStructure > *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg9 = *argp9; 
  arg10 = jarg10 ? true : false; 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (MtMCrossCurrencyBasisSwapRateHelper *)new MtMCrossCurrencyBasisSwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,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 ? new ext::shared_ptr<  MtMCrossCurrencyBasisSwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MtMCrossCurrencyBasisSwapRateHelper(void * jarg1) {
  MtMCrossCurrencyBasisSwapRateHelper *arg1 = (MtMCrossCurrencyBasisSwapRateHelper *) 0 ;
  ext::shared_ptr< MtMCrossCurrencyBasisSwapRateHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MtMCrossCurrencyBasisSwapRateHelper > *)jarg1;
  arg1 = (MtMCrossCurrencyBasisSwapRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IborIborBasisSwapRateHelper(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6, void * jarg7, void * jarg8, void * jarg9, unsigned int jarg10) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  SwigValueWrapper< Calendar > arg4 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  Handle< YieldTermStructure > arg9 ;
  bool arg10 ;
  Calendar *argp4 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  ext::shared_ptr< IborIndex > tempnull8 ;
  Handle< YieldTermStructure > *argp9 ;
  IborIborBasisSwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  argp4 = (Calendar *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = jarg8 ? (ext::shared_ptr< IborIndex > *)jarg8 : &tempnull8; 
  argp9 = (Handle< YieldTermStructure > *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg9 = *argp9; 
  arg10 = jarg10 ? true : false; 
  {
    try {
      result = (IborIborBasisSwapRateHelper *)new IborIborBasisSwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,arg4,arg5,arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  IborIborBasisSwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IborIborBasisSwapRateHelper(void * jarg1) {
  IborIborBasisSwapRateHelper *arg1 = (IborIborBasisSwapRateHelper *) 0 ;
  ext::shared_ptr< IborIborBasisSwapRateHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  IborIborBasisSwapRateHelper > *)jarg1;
  arg1 = (IborIborBasisSwapRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIborBasisSwapRateHelper__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6, void * jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  SwigValueWrapper< Calendar > arg4 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  ext::shared_ptr< OvernightIndex > *arg7 = 0 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  Handle< YieldTermStructure > arg9 ;
  Calendar *argp4 ;
  ext::shared_ptr< OvernightIndex > tempnull7 ;
  ext::shared_ptr< IborIndex > tempnull8 ;
  Handle< YieldTermStructure > *argp9 ;
  OvernightIborBasisSwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  argp4 = (Calendar *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = jarg7 ? (ext::shared_ptr< OvernightIndex > *)jarg7 : &tempnull7; 
  arg8 = jarg8 ? (ext::shared_ptr< IborIndex > *)jarg8 : &tempnull8; 
  argp9 = (Handle< YieldTermStructure > *)jarg9; 
  if (!argp9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg9 = *argp9; 
  {
    try {
      result = (OvernightIborBasisSwapRateHelper *)new OvernightIborBasisSwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,arg4,arg5,arg6,(ext::shared_ptr< OvernightIndex > const &)*arg7,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  OvernightIborBasisSwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OvernightIborBasisSwapRateHelper__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 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  SwigValueWrapper< Calendar > arg4 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  ext::shared_ptr< OvernightIndex > *arg7 = 0 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  Calendar *argp4 ;
  ext::shared_ptr< OvernightIndex > tempnull7 ;
  ext::shared_ptr< IborIndex > tempnull8 ;
  OvernightIborBasisSwapRateHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Natural)jarg3; 
  argp4 = (Calendar *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Calendar", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = jarg7 ? (ext::shared_ptr< OvernightIndex > *)jarg7 : &tempnull7; 
  arg8 = jarg8 ? (ext::shared_ptr< IborIndex > *)jarg8 : &tempnull8; 
  {
    try {
      result = (OvernightIborBasisSwapRateHelper *)new OvernightIborBasisSwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,arg4,arg5,arg6,(ext::shared_ptr< OvernightIndex > const &)*arg7,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  OvernightIborBasisSwapRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_OvernightIborBasisSwapRateHelper(void * jarg1) {
  OvernightIborBasisSwapRateHelper *arg1 = (OvernightIborBasisSwapRateHelper *) 0 ;
  ext::shared_ptr< OvernightIborBasisSwapRateHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OvernightIborBasisSwapRateHelper > *)jarg1;
  arg1 = (OvernightIborBasisSwapRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ArithmeticOISRateHelper__SWIG_0(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, double jarg8, double jarg9, unsigned int jarg10, void * jarg11) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Frequency arg3 ;
  Handle< Quote > *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > arg5 ;
  Frequency arg6 ;
  Handle< Quote > arg7 ;
  Real arg8 ;
  Real arg9 ;
  bool arg10 ;
  Handle< YieldTermStructure > arg11 ;
  Handle< Quote > *argp7 ;
  Handle< YieldTermStructure > *argp11 ;
  ArithmeticOISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Frequency)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  if (jarg5) arg5 = *(ext::shared_ptr< OvernightIndex > *)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Handle< Quote > *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = jarg10 ? true : false; 
  argp11 = (Handle< YieldTermStructure > *)jarg11; 
  if (!argp11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg11 = *argp11; 
  {
    try {
      result = (ArithmeticOISRateHelper *)new ArithmeticOISRateHelper(arg1,(Period const &)*arg2,arg3,(Handle< Quote > 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 ? new ext::shared_ptr<  ArithmeticOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ArithmeticOISRateHelper__SWIG_1(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, double jarg8, double jarg9, unsigned int jarg10) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Frequency arg3 ;
  Handle< Quote > *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > arg5 ;
  Frequency arg6 ;
  Handle< Quote > arg7 ;
  Real arg8 ;
  Real arg9 ;
  bool arg10 ;
  Handle< Quote > *argp7 ;
  ArithmeticOISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Frequency)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  if (jarg5) arg5 = *(ext::shared_ptr< OvernightIndex > *)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Handle< Quote > *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = jarg10 ? true : false; 
  {
    try {
      result = (ArithmeticOISRateHelper *)new ArithmeticOISRateHelper(arg1,(Period const &)*arg2,arg3,(Handle< Quote > 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 ? new ext::shared_ptr<  ArithmeticOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ArithmeticOISRateHelper__SWIG_2(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, double jarg8, double jarg9) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Frequency arg3 ;
  Handle< Quote > *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > arg5 ;
  Frequency arg6 ;
  Handle< Quote > arg7 ;
  Real arg8 ;
  Real arg9 ;
  Handle< Quote > *argp7 ;
  ArithmeticOISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Frequency)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  if (jarg5) arg5 = *(ext::shared_ptr< OvernightIndex > *)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Handle< Quote > *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (ArithmeticOISRateHelper *)new ArithmeticOISRateHelper(arg1,(Period const &)*arg2,arg3,(Handle< Quote > 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 ? new ext::shared_ptr<  ArithmeticOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ArithmeticOISRateHelper__SWIG_3(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7, double jarg8) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Frequency arg3 ;
  Handle< Quote > *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > arg5 ;
  Frequency arg6 ;
  Handle< Quote > arg7 ;
  Real arg8 ;
  Handle< Quote > *argp7 ;
  ArithmeticOISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Frequency)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  if (jarg5) arg5 = *(ext::shared_ptr< OvernightIndex > *)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Handle< Quote > *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg7 = *argp7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (ArithmeticOISRateHelper *)new ArithmeticOISRateHelper(arg1,(Period const &)*arg2,arg3,(Handle< Quote > 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 ? new ext::shared_ptr<  ArithmeticOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ArithmeticOISRateHelper__SWIG_4(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, int jarg6, void * jarg7) {
  void * jresult ;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Frequency arg3 ;
  Handle< Quote > *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > arg5 ;
  Frequency arg6 ;
  Handle< Quote > arg7 ;
  Handle< Quote > *argp7 ;
  ArithmeticOISRateHelper *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Frequency)jarg3; 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  if (jarg5) arg5 = *(ext::shared_ptr< OvernightIndex > *)jarg5; 
  arg6 = (Frequency)jarg6; 
  argp7 = (Handle< Quote > *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< Quote >", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (ArithmeticOISRateHelper *)new ArithmeticOISRateHelper(arg1,(Period const &)*arg2,arg3,(Handle< Quote > 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 ? new ext::shared_ptr<  ArithmeticOISRateHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ArithmeticOISRateHelper_swap(void * jarg1) {
  void * jresult ;
  ArithmeticOISRateHelper *arg1 = (ArithmeticOISRateHelper *) 0 ;
  ext::shared_ptr< ArithmeticOISRateHelper const > *smartarg1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS > result;
  
  
  smartarg1 = (ext::shared_ptr< const ArithmeticOISRateHelper > *)jarg1;
  arg1 = (ArithmeticOISRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((ArithmeticOISRateHelper const *)arg1)->swap();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< ArithmeticAverageOIS >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ArithmeticOISRateHelper(void * jarg1) {
  ArithmeticOISRateHelper *arg1 = (ArithmeticOISRateHelper *) 0 ;
  ext::shared_ptr< ArithmeticOISRateHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ArithmeticOISRateHelper > *)jarg1;
  arg1 = (ArithmeticOISRateHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  
  arg1 = (std::vector< ext::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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  ext::shared_ptr< RateHelper > *arg2 = 0 ;
  ext::shared_ptr< RateHelper > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< RateHelper > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (std::vector< ext::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< ext::shared_ptr< RateHelper > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< RateHelper > > *)new std::vector< ext::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< ext::shared_ptr< RateHelper > > *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< ext::shared_ptr< RateHelper > > *)new std::vector< ext::shared_ptr< RateHelper > >((std::vector< ext::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< ext::shared_ptr< RateHelper > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< RateHelper > > *)new_std_vector_Sl_ext_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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< RateHelper > result;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_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 = result ? new ext::shared_ptr< RateHelper >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_RateHelperVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< RateHelper > >::value_type *) &std_vector_Sl_ext_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 = *result ? new std::vector< ext::shared_ptr< RateHelper > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_RateHelperVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< RateHelper > *arg3 = 0 ;
  ext::shared_ptr< RateHelper > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< RateHelper > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__setitem(arg1,arg2,(ext::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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__AddRange(arg1,(std::vector< ext::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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< RateHelper > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< RateHelper > > *)std_vector_Sl_ext_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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< RateHelper > *arg3 = 0 ;
  ext::shared_ptr< RateHelper > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< RateHelper > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__Insert(arg1,arg2,(ext::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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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 ;
  ext::shared_ptr< RateHelper > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< RateHelper > tempnull1 ;
  std::vector< ext::shared_ptr< RateHelper > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< RateHelper > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< RateHelper > > *)std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__Repeat((ext::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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  ext::shared_ptr< RateHelper > *arg2 = 0 ;
  ext::shared_ptr< RateHelper > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< RateHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__Contains(arg1,(ext::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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  ext::shared_ptr< RateHelper > *arg2 = 0 ;
  ext::shared_ptr< RateHelper > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< RateHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__IndexOf(arg1,(ext::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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  ext::shared_ptr< RateHelper > *arg2 = 0 ;
  ext::shared_ptr< RateHelper > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< RateHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__LastIndexOf(arg1,(ext::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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  ext::shared_ptr< RateHelper > *arg2 = 0 ;
  ext::shared_ptr< RateHelper > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< RateHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__Remove(arg1,(ext::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< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  
  arg1 = (std::vector< ext::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_BondHelperVector_Clear(void * jarg1) {
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)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_BondHelperVector_Add(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  ext::shared_ptr< BondHelper > *arg2 = 0 ;
  ext::shared_ptr< BondHelper > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BondHelper > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::shared_ptr< BondHelper > 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_BondHelperVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< BondHelper > > 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_BondHelperVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< BondHelper > > 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_BondHelperVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< BondHelper > >::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_BondHelperVector__SWIG_0() {
  void * jresult ;
  std::vector< ext::shared_ptr< BondHelper > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< BondHelper > > *)new std::vector< ext::shared_ptr< BondHelper > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BondHelperVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< ext::shared_ptr< BondHelper > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BondHelper > > *)new_std_vector_Sl_ext_shared_ptr_Sl_BondHelper_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_BondHelperVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< BondHelper > result;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_BondHelper_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 = result ? new ext::shared_ptr< BondHelper >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BondHelperVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BondHelper > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_BondHelper_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 = *result ? new std::vector< ext::shared_ptr< BondHelper > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_BondHelperVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< BondHelper > *arg3 = 0 ;
  ext::shared_ptr< BondHelper > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< BondHelper > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__setitem(arg1,arg2,(ext::shared_ptr< BondHelper > 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_BondHelperVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BondHelper > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__AddRange(arg1,(std::vector< ext::shared_ptr< BondHelper > > 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_BondHelperVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< BondHelper > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BondHelper > > *)std_vector_Sl_ext_shared_ptr_Sl_BondHelper_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_BondHelperVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< BondHelper > *arg3 = 0 ;
  ext::shared_ptr< BondHelper > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< BondHelper > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__Insert(arg1,arg2,(ext::shared_ptr< BondHelper > 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_BondHelperVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< BondHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BondHelper > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::shared_ptr< BondHelper > > 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_BondHelperVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BondHelper_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_BondHelperVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BondHelper_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_BondHelperVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< BondHelper > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< BondHelper > tempnull1 ;
  std::vector< ext::shared_ptr< BondHelper > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BondHelper > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BondHelper > > *)std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__Repeat((ext::shared_ptr< BondHelper > 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_BondHelperVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BondHelper_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_BondHelperVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BondHelper_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_BondHelperVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< BondHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BondHelper > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::shared_ptr< BondHelper > > 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_BondHelperVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  ext::shared_ptr< BondHelper > *arg2 = 0 ;
  ext::shared_ptr< BondHelper > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BondHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__Contains(arg1,(ext::shared_ptr< BondHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_BondHelperVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  ext::shared_ptr< BondHelper > *arg2 = 0 ;
  ext::shared_ptr< BondHelper > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BondHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__IndexOf(arg1,(ext::shared_ptr< BondHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_BondHelperVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  ext::shared_ptr< BondHelper > *arg2 = 0 ;
  ext::shared_ptr< BondHelper > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BondHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__LastIndexOf(arg1,(ext::shared_ptr< BondHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_BondHelperVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  ext::shared_ptr< BondHelper > *arg2 = 0 ;
  ext::shared_ptr< BondHelper > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< BondHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__Remove(arg1,(ext::shared_ptr< BondHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_BondHelperVector(void * jarg1) {
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_depositratehelper(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< RateHelper > arg1 ;
  ext::shared_ptr< DepositRateHelper > result;
  
  if (jarg1) arg1 = *(ext::shared_ptr< RateHelper > *)jarg1; 
  {
    try {
      result = as_depositratehelper(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< DepositRateHelper >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_as_fraratehelper(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< RateHelper > arg1 ;
  ext::shared_ptr< FraRateHelper > result;
  
  if (jarg1) arg1 = *(ext::shared_ptr< RateHelper > *)jarg1; 
  {
    try {
      result = as_fraratehelper(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< FraRateHelper >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_as_swapratehelper(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< RateHelper > arg1 ;
  ext::shared_ptr< SwapRateHelper > result;
  
  if (jarg1) arg1 = *(ext::shared_ptr< RateHelper > *)jarg1; 
  {
    try {
      result = as_swapratehelper(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< SwapRateHelper >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_as_oisratehelper(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< RateHelper > arg1 ;
  ext::shared_ptr< OISRateHelper > result;
  
  if (jarg1) arg1 = *(ext::shared_ptr< RateHelper > *)jarg1; 
  {
    try {
      result = as_oisratehelper(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< OISRateHelper >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_as_constnotionalcrosscurrencybasisswapratehelper(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< RateHelper > arg1 ;
  ext::shared_ptr< ConstNotionalCrossCurrencyBasisSwapRateHelper > result;
  
  if (jarg1) arg1 = *(ext::shared_ptr< RateHelper > *)jarg1; 
  {
    try {
      result = as_constnotionalcrosscurrencybasisswapratehelper(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< ConstNotionalCrossCurrencyBasisSwapRateHelper >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_as_mtmcrosscurrencybasisswapratehelper(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< RateHelper > arg1 ;
  ext::shared_ptr< MtMCrossCurrencyBasisSwapRateHelper > result;
  
  if (jarg1) arg1 = *(ext::shared_ptr< RateHelper > *)jarg1; 
  {
    try {
      result = as_mtmcrosscurrencybasisswapratehelper(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< MtMCrossCurrencyBasisSwapRateHelper >(result) : 0; 
  return jresult;
}


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_IterativeBootstrap__SWIG_0(double jarg1, double jarg2, double jarg3, unsigned long jarg4, double jarg5, double jarg6, unsigned int jarg7, unsigned long jarg8, unsigned long jarg9) {
  void * jresult ;
  doubleOrNull arg1 ;
  doubleOrNull arg2 ;
  doubleOrNull arg3 ;
  Size arg4 ;
  Real arg5 ;
  Real arg6 ;
  bool arg7 ;
  Size arg8 ;
  Size arg9 ;
  _IterativeBootstrap *result = 0 ;
  
  arg1 = (doubleOrNull)jarg1; 
  arg2 = (doubleOrNull)jarg2; 
  arg3 = (doubleOrNull)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (Size)jarg8; 
  arg9 = (Size)jarg9; 
  {
    try {
      result = (_IterativeBootstrap *)new _IterativeBootstrap(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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IterativeBootstrap__SWIG_1(double jarg1, double jarg2, double jarg3, unsigned long jarg4, double jarg5, double jarg6, unsigned int jarg7, unsigned long jarg8) {
  void * jresult ;
  doubleOrNull arg1 ;
  doubleOrNull arg2 ;
  doubleOrNull arg3 ;
  Size arg4 ;
  Real arg5 ;
  Real arg6 ;
  bool arg7 ;
  Size arg8 ;
  _IterativeBootstrap *result = 0 ;
  
  arg1 = (doubleOrNull)jarg1; 
  arg2 = (doubleOrNull)jarg2; 
  arg3 = (doubleOrNull)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = jarg7 ? true : false; 
  arg8 = (Size)jarg8; 
  {
    try {
      result = (_IterativeBootstrap *)new _IterativeBootstrap(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_IterativeBootstrap__SWIG_2(double jarg1, double jarg2, double jarg3, unsigned long jarg4, double jarg5, double jarg6, unsigned int jarg7) {
  void * jresult ;
  doubleOrNull arg1 ;
  doubleOrNull arg2 ;
  doubleOrNull arg3 ;
  Size arg4 ;
  Real arg5 ;
  Real arg6 ;
  bool arg7 ;
  _IterativeBootstrap *result = 0 ;
  
  arg1 = (doubleOrNull)jarg1; 
  arg2 = (doubleOrNull)jarg2; 
  arg3 = (doubleOrNull)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (_IterativeBootstrap *)new _IterativeBootstrap(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_IterativeBootstrap__SWIG_3(double jarg1, double jarg2, double jarg3, unsigned long jarg4, double jarg5, double jarg6) {
  void * jresult ;
  doubleOrNull arg1 ;
  doubleOrNull arg2 ;
  doubleOrNull arg3 ;
  Size arg4 ;
  Real arg5 ;
  Real arg6 ;
  _IterativeBootstrap *result = 0 ;
  
  arg1 = (doubleOrNull)jarg1; 
  arg2 = (doubleOrNull)jarg2; 
  arg3 = (doubleOrNull)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (_IterativeBootstrap *)new _IterativeBootstrap(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_IterativeBootstrap__SWIG_4(double jarg1, double jarg2, double jarg3, unsigned long jarg4, double jarg5) {
  void * jresult ;
  doubleOrNull arg1 ;
  doubleOrNull arg2 ;
  doubleOrNull arg3 ;
  Size arg4 ;
  Real arg5 ;
  _IterativeBootstrap *result = 0 ;
  
  arg1 = (doubleOrNull)jarg1; 
  arg2 = (doubleOrNull)jarg2; 
  arg3 = (doubleOrNull)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (_IterativeBootstrap *)new _IterativeBootstrap(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_IterativeBootstrap__SWIG_5(double jarg1, double jarg2, double jarg3, unsigned long jarg4) {
  void * jresult ;
  doubleOrNull arg1 ;
  doubleOrNull arg2 ;
  doubleOrNull arg3 ;
  Size arg4 ;
  _IterativeBootstrap *result = 0 ;
  
  arg1 = (doubleOrNull)jarg1; 
  arg2 = (doubleOrNull)jarg2; 
  arg3 = (doubleOrNull)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (_IterativeBootstrap *)new _IterativeBootstrap(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_IterativeBootstrap__SWIG_6(double jarg1, double jarg2, double jarg3) {
  void * jresult ;
  doubleOrNull arg1 ;
  doubleOrNull arg2 ;
  doubleOrNull arg3 ;
  _IterativeBootstrap *result = 0 ;
  
  arg1 = (doubleOrNull)jarg1; 
  arg2 = (doubleOrNull)jarg2; 
  arg3 = (doubleOrNull)jarg3; 
  {
    try {
      result = (_IterativeBootstrap *)new _IterativeBootstrap(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_IterativeBootstrap__SWIG_7(double jarg1, double jarg2) {
  void * jresult ;
  doubleOrNull arg1 ;
  doubleOrNull arg2 ;
  _IterativeBootstrap *result = 0 ;
  
  arg1 = (doubleOrNull)jarg1; 
  arg2 = (doubleOrNull)jarg2; 
  {
    try {
      result = (_IterativeBootstrap *)new _IterativeBootstrap(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_IterativeBootstrap__SWIG_8(double jarg1) {
  void * jresult ;
  doubleOrNull arg1 ;
  _IterativeBootstrap *result = 0 ;
  
  arg1 = (doubleOrNull)jarg1; 
  {
    try {
      result = (_IterativeBootstrap *)new _IterativeBootstrap(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IterativeBootstrap(void * jarg1) {
  _IterativeBootstrap *arg1 = (_IterativeBootstrap *) 0 ;
  
  arg1 = (_IterativeBootstrap *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  BackwardFlat *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (BackwardFlat *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & is null", 0);
    return 0;
  } 
  arg7 = (_IterativeBootstrap *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(BackwardFlat const &)*arg6,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  BackwardFlat *arg6 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (BackwardFlat *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*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 = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  BackwardFlat *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (BackwardFlat *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & is null", 0);
    return 0;
  } 
  arg8 = (_IterativeBootstrap *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(BackwardFlat const &)*arg7,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  BackwardFlat *arg7 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (BackwardFlat *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*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 = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  BackwardFlat *arg5 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg5 = (BackwardFlat *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_12(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  BackwardFlat *arg6 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg6 = (BackwardFlat *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*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 = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatForward__SWIG_13(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseFlatForward_dates(void * jarg1) {
  void * jresult ;
  PiecewiseFlatForward *arg1 = (PiecewiseFlatForward *) 0 ;
  ext::shared_ptr< PiecewiseFlatForward const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseFlatForward > *)jarg1;
  arg1 = (PiecewiseFlatForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseFlatForward 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_PiecewiseFlatForward_times(void * jarg1) {
  void * jresult ;
  PiecewiseFlatForward *arg1 = (PiecewiseFlatForward *) 0 ;
  ext::shared_ptr< PiecewiseFlatForward const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseFlatForward > *)jarg1;
  arg1 = (PiecewiseFlatForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseFlatForward 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseFlatForward_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseFlatForward *arg1 = (PiecewiseFlatForward *) 0 ;
  ext::shared_ptr< PiecewiseFlatForward const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseFlatForward > *)jarg1;
  arg1 = (PiecewiseFlatForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseFlatForward const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PiecewiseFlatForward_recalculate(void * jarg1) {
  PiecewiseFlatForward *arg1 = (PiecewiseFlatForward *) 0 ;
  ext::shared_ptr< PiecewiseFlatForward > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseFlatForward > *)jarg1;
  arg1 = (PiecewiseFlatForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseFlatForward_freeze(void * jarg1) {
  PiecewiseFlatForward *arg1 = (PiecewiseFlatForward *) 0 ;
  ext::shared_ptr< PiecewiseFlatForward > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseFlatForward > *)jarg1;
  arg1 = (PiecewiseFlatForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseFlatForward_unfreeze(void * jarg1) {
  PiecewiseFlatForward *arg1 = (PiecewiseFlatForward *) 0 ;
  ext::shared_ptr< PiecewiseFlatForward > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseFlatForward > *)jarg1;
  arg1 = (PiecewiseFlatForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_delete_PiecewiseFlatForward(void * jarg1) {
  PiecewiseFlatForward *arg1 = (PiecewiseFlatForward *) 0 ;
  ext::shared_ptr< PiecewiseFlatForward > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseFlatForward > *)jarg1;
  arg1 = (PiecewiseFlatForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogLinearDiscount__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  LogLinear *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (LogLinear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogLinear const & is null", 0);
    return 0;
  } 
  arg7 = (_IterativeBootstrap *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(LogLinear const &)*arg6,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogLinearDiscount__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  LogLinear *arg6 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (LogLinear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogLinear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(LogLinear 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 ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogLinearDiscount__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogLinearDiscount__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogLinearDiscount__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogLinearDiscount__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  LogLinear *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (LogLinear *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogLinear const & is null", 0);
    return 0;
  } 
  arg8 = (_IterativeBootstrap *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(LogLinear const &)*arg7,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogLinearDiscount__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  LogLinear *arg7 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (LogLinear *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogLinear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(LogLinear 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 ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogLinearDiscount__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogLinearDiscount__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogLinearDiscount__SWIG_9(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogLinearDiscount__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  LogLinear *arg5 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg5 = (LogLinear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogLinear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogLinearDiscount__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogLinearDiscount__SWIG_12(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  LogLinear *arg6 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg6 = (LogLinear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogLinear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(LogLinear 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 ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogLinearDiscount__SWIG_13(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLogLinearDiscount_dates(void * jarg1) {
  void * jresult ;
  PiecewiseLogLinearDiscount *arg1 = (PiecewiseLogLinearDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseLogLinearDiscount > *)jarg1;
  arg1 = (PiecewiseLogLinearDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseLogLinearDiscount 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_PiecewiseLogLinearDiscount_times(void * jarg1) {
  void * jresult ;
  PiecewiseLogLinearDiscount *arg1 = (PiecewiseLogLinearDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseLogLinearDiscount > *)jarg1;
  arg1 = (PiecewiseLogLinearDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseLogLinearDiscount 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLogLinearDiscount_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseLogLinearDiscount *arg1 = (PiecewiseLogLinearDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseLogLinearDiscount > *)jarg1;
  arg1 = (PiecewiseLogLinearDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseLogLinearDiscount const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PiecewiseLogLinearDiscount_recalculate(void * jarg1) {
  PiecewiseLogLinearDiscount *arg1 = (PiecewiseLogLinearDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLogLinearDiscount > *)jarg1;
  arg1 = (PiecewiseLogLinearDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseLogLinearDiscount_freeze(void * jarg1) {
  PiecewiseLogLinearDiscount *arg1 = (PiecewiseLogLinearDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLogLinearDiscount > *)jarg1;
  arg1 = (PiecewiseLogLinearDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseLogLinearDiscount_unfreeze(void * jarg1) {
  PiecewiseLogLinearDiscount *arg1 = (PiecewiseLogLinearDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLogLinearDiscount > *)jarg1;
  arg1 = (PiecewiseLogLinearDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_delete_PiecewiseLogLinearDiscount(void * jarg1) {
  PiecewiseLogLinearDiscount *arg1 = (PiecewiseLogLinearDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLogLinearDiscount > *)jarg1;
  arg1 = (PiecewiseLogLinearDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Linear *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (Linear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg7 = (_IterativeBootstrap *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(Linear const &)*arg6,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Linear *arg6 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (Linear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(Linear 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 ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Linear *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (Linear *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg8 = (_IterativeBootstrap *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(Linear const &)*arg7,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Linear *arg7 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (Linear *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > 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 = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  Linear *arg5 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_12(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  Linear *arg6 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg6 = (Linear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(Linear 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 ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearForward__SWIG_13(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLinearForward_dates(void * jarg1) {
  void * jresult ;
  PiecewiseLinearForward *arg1 = (PiecewiseLinearForward *) 0 ;
  ext::shared_ptr< PiecewiseLinearForward const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseLinearForward > *)jarg1;
  arg1 = (PiecewiseLinearForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseLinearForward 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_PiecewiseLinearForward_times(void * jarg1) {
  void * jresult ;
  PiecewiseLinearForward *arg1 = (PiecewiseLinearForward *) 0 ;
  ext::shared_ptr< PiecewiseLinearForward const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseLinearForward > *)jarg1;
  arg1 = (PiecewiseLinearForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseLinearForward 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLinearForward_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseLinearForward *arg1 = (PiecewiseLinearForward *) 0 ;
  ext::shared_ptr< PiecewiseLinearForward const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseLinearForward > *)jarg1;
  arg1 = (PiecewiseLinearForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseLinearForward const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PiecewiseLinearForward_recalculate(void * jarg1) {
  PiecewiseLinearForward *arg1 = (PiecewiseLinearForward *) 0 ;
  ext::shared_ptr< PiecewiseLinearForward > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLinearForward > *)jarg1;
  arg1 = (PiecewiseLinearForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseLinearForward_freeze(void * jarg1) {
  PiecewiseLinearForward *arg1 = (PiecewiseLinearForward *) 0 ;
  ext::shared_ptr< PiecewiseLinearForward > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLinearForward > *)jarg1;
  arg1 = (PiecewiseLinearForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseLinearForward_unfreeze(void * jarg1) {
  PiecewiseLinearForward *arg1 = (PiecewiseLinearForward *) 0 ;
  ext::shared_ptr< PiecewiseLinearForward > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLinearForward > *)jarg1;
  arg1 = (PiecewiseLinearForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_delete_PiecewiseLinearForward(void * jarg1) {
  PiecewiseLinearForward *arg1 = (PiecewiseLinearForward *) 0 ;
  ext::shared_ptr< PiecewiseLinearForward > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLinearForward > *)jarg1;
  arg1 = (PiecewiseLinearForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Linear *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (Linear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg7 = (_IterativeBootstrap *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(Linear const &)*arg6,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Linear *arg6 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (Linear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(Linear 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 ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Linear *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (Linear *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg8 = (_IterativeBootstrap *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(Linear const &)*arg7,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Linear *arg7 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (Linear *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > 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 = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  Linear *arg5 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_12(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  Linear *arg6 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg6 = (Linear *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(Linear 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 ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLinearZero__SWIG_13(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLinearZero_dates(void * jarg1) {
  void * jresult ;
  PiecewiseLinearZero *arg1 = (PiecewiseLinearZero *) 0 ;
  ext::shared_ptr< PiecewiseLinearZero const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseLinearZero > *)jarg1;
  arg1 = (PiecewiseLinearZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseLinearZero 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_PiecewiseLinearZero_times(void * jarg1) {
  void * jresult ;
  PiecewiseLinearZero *arg1 = (PiecewiseLinearZero *) 0 ;
  ext::shared_ptr< PiecewiseLinearZero const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseLinearZero > *)jarg1;
  arg1 = (PiecewiseLinearZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseLinearZero 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLinearZero_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseLinearZero *arg1 = (PiecewiseLinearZero *) 0 ;
  ext::shared_ptr< PiecewiseLinearZero const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseLinearZero > *)jarg1;
  arg1 = (PiecewiseLinearZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseLinearZero const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PiecewiseLinearZero_recalculate(void * jarg1) {
  PiecewiseLinearZero *arg1 = (PiecewiseLinearZero *) 0 ;
  ext::shared_ptr< PiecewiseLinearZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLinearZero > *)jarg1;
  arg1 = (PiecewiseLinearZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseLinearZero_freeze(void * jarg1) {
  PiecewiseLinearZero *arg1 = (PiecewiseLinearZero *) 0 ;
  ext::shared_ptr< PiecewiseLinearZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLinearZero > *)jarg1;
  arg1 = (PiecewiseLinearZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseLinearZero_unfreeze(void * jarg1) {
  PiecewiseLinearZero *arg1 = (PiecewiseLinearZero *) 0 ;
  ext::shared_ptr< PiecewiseLinearZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLinearZero > *)jarg1;
  arg1 = (PiecewiseLinearZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_delete_PiecewiseLinearZero(void * jarg1) {
  PiecewiseLinearZero *arg1 = (PiecewiseLinearZero *) 0 ;
  ext::shared_ptr< PiecewiseLinearZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLinearZero > *)jarg1;
  arg1 = (PiecewiseLinearZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (Cubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  arg7 = (_IterativeBootstrap *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(Cubic const &)*arg6,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (Cubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(Cubic 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 ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Cubic *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (Cubic *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  arg8 = (_IterativeBootstrap *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(Cubic const &)*arg7,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Cubic *arg7 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (Cubic *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*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 = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  Cubic *arg5 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg5 = (Cubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_12(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg6 = (Cubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(Cubic 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 ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseCubicZero__SWIG_13(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseCubicZero_dates(void * jarg1) {
  void * jresult ;
  PiecewiseCubicZero *arg1 = (PiecewiseCubicZero *) 0 ;
  ext::shared_ptr< PiecewiseCubicZero const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseCubicZero > *)jarg1;
  arg1 = (PiecewiseCubicZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseCubicZero 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_PiecewiseCubicZero_times(void * jarg1) {
  void * jresult ;
  PiecewiseCubicZero *arg1 = (PiecewiseCubicZero *) 0 ;
  ext::shared_ptr< PiecewiseCubicZero const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseCubicZero > *)jarg1;
  arg1 = (PiecewiseCubicZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseCubicZero 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseCubicZero_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseCubicZero *arg1 = (PiecewiseCubicZero *) 0 ;
  ext::shared_ptr< PiecewiseCubicZero const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseCubicZero > *)jarg1;
  arg1 = (PiecewiseCubicZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseCubicZero const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PiecewiseCubicZero_recalculate(void * jarg1) {
  PiecewiseCubicZero *arg1 = (PiecewiseCubicZero *) 0 ;
  ext::shared_ptr< PiecewiseCubicZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseCubicZero > *)jarg1;
  arg1 = (PiecewiseCubicZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseCubicZero_freeze(void * jarg1) {
  PiecewiseCubicZero *arg1 = (PiecewiseCubicZero *) 0 ;
  ext::shared_ptr< PiecewiseCubicZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseCubicZero > *)jarg1;
  arg1 = (PiecewiseCubicZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseCubicZero_unfreeze(void * jarg1) {
  PiecewiseCubicZero *arg1 = (PiecewiseCubicZero *) 0 ;
  ext::shared_ptr< PiecewiseCubicZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseCubicZero > *)jarg1;
  arg1 = (PiecewiseCubicZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_delete_PiecewiseCubicZero(void * jarg1) {
  PiecewiseCubicZero *arg1 = (PiecewiseCubicZero *) 0 ;
  ext::shared_ptr< PiecewiseCubicZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseCubicZero > *)jarg1;
  arg1 = (PiecewiseCubicZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  MonotonicLogCubic *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (MonotonicLogCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicLogCubic const & is null", 0);
    return 0;
  } 
  arg7 = (_IterativeBootstrap *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(MonotonicLogCubic const &)*arg6,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  MonotonicLogCubic *arg6 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (MonotonicLogCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicLogCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(MonotonicLogCubic 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 ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  MonotonicLogCubic *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (MonotonicLogCubic *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicLogCubic const & is null", 0);
    return 0;
  } 
  arg8 = (_IterativeBootstrap *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(MonotonicLogCubic const &)*arg7,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  MonotonicLogCubic *arg7 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (MonotonicLogCubic *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicLogCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*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 = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  MonotonicLogCubic *arg5 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg5 = (MonotonicLogCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicLogCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(MonotonicLogCubic 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 ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_12(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  MonotonicLogCubic *arg6 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg6 = (MonotonicLogCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicLogCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(MonotonicLogCubic 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 ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogCubicDiscount__SWIG_13(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLogCubicDiscount_dates(void * jarg1) {
  void * jresult ;
  PiecewiseLogCubicDiscount *arg1 = (PiecewiseLogCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseLogCubicDiscount > *)jarg1;
  arg1 = (PiecewiseLogCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseLogCubicDiscount 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_PiecewiseLogCubicDiscount_times(void * jarg1) {
  void * jresult ;
  PiecewiseLogCubicDiscount *arg1 = (PiecewiseLogCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseLogCubicDiscount > *)jarg1;
  arg1 = (PiecewiseLogCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseLogCubicDiscount 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLogCubicDiscount_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseLogCubicDiscount *arg1 = (PiecewiseLogCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseLogCubicDiscount > *)jarg1;
  arg1 = (PiecewiseLogCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseLogCubicDiscount const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PiecewiseLogCubicDiscount_recalculate(void * jarg1) {
  PiecewiseLogCubicDiscount *arg1 = (PiecewiseLogCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLogCubicDiscount > *)jarg1;
  arg1 = (PiecewiseLogCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseLogCubicDiscount_freeze(void * jarg1) {
  PiecewiseLogCubicDiscount *arg1 = (PiecewiseLogCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLogCubicDiscount > *)jarg1;
  arg1 = (PiecewiseLogCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseLogCubicDiscount_unfreeze(void * jarg1) {
  PiecewiseLogCubicDiscount *arg1 = (PiecewiseLogCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLogCubicDiscount > *)jarg1;
  arg1 = (PiecewiseLogCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_delete_PiecewiseLogCubicDiscount(void * jarg1) {
  PiecewiseLogCubicDiscount *arg1 = (PiecewiseLogCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLogCubicDiscount > *)jarg1;
  arg1 = (PiecewiseLogCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseSplineCubicDiscount__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (SplineCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg7 = (_IterativeBootstrap *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(SplineCubic const &)*arg6,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseSplineCubicDiscount__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (SplineCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(SplineCubic 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 ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseSplineCubicDiscount__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseSplineCubicDiscount__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseSplineCubicDiscount__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseSplineCubicDiscount__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  SplineCubic *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (SplineCubic *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg8 = (_IterativeBootstrap *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(SplineCubic const &)*arg7,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseSplineCubicDiscount__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  SplineCubic *arg7 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (SplineCubic *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(SplineCubic 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 ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseSplineCubicDiscount__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseSplineCubicDiscount__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseSplineCubicDiscount__SWIG_9(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseSplineCubicDiscount__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  SplineCubic *arg5 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg5 = (SplineCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(SplineCubic 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 ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseSplineCubicDiscount__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseSplineCubicDiscount__SWIG_12(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg6 = (SplineCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(SplineCubic 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 ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseSplineCubicDiscount__SWIG_13(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseSplineCubicDiscount_dates(void * jarg1) {
  void * jresult ;
  PiecewiseSplineCubicDiscount *arg1 = (PiecewiseSplineCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseSplineCubicDiscount > *)jarg1;
  arg1 = (PiecewiseSplineCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseSplineCubicDiscount 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_PiecewiseSplineCubicDiscount_times(void * jarg1) {
  void * jresult ;
  PiecewiseSplineCubicDiscount *arg1 = (PiecewiseSplineCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseSplineCubicDiscount > *)jarg1;
  arg1 = (PiecewiseSplineCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseSplineCubicDiscount 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseSplineCubicDiscount_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseSplineCubicDiscount *arg1 = (PiecewiseSplineCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseSplineCubicDiscount > *)jarg1;
  arg1 = (PiecewiseSplineCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseSplineCubicDiscount const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PiecewiseSplineCubicDiscount_recalculate(void * jarg1) {
  PiecewiseSplineCubicDiscount *arg1 = (PiecewiseSplineCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseSplineCubicDiscount > *)jarg1;
  arg1 = (PiecewiseSplineCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseSplineCubicDiscount_freeze(void * jarg1) {
  PiecewiseSplineCubicDiscount *arg1 = (PiecewiseSplineCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseSplineCubicDiscount > *)jarg1;
  arg1 = (PiecewiseSplineCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseSplineCubicDiscount_unfreeze(void * jarg1) {
  PiecewiseSplineCubicDiscount *arg1 = (PiecewiseSplineCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseSplineCubicDiscount > *)jarg1;
  arg1 = (PiecewiseSplineCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_delete_PiecewiseSplineCubicDiscount(void * jarg1) {
  PiecewiseSplineCubicDiscount *arg1 = (PiecewiseSplineCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseSplineCubicDiscount > *)jarg1;
  arg1 = (PiecewiseSplineCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerZero__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Kruger *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (Kruger *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Kruger const & is null", 0);
    return 0;
  } 
  arg7 = (_IterativeBootstrap *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(Kruger const &)*arg6,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerZero__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  Kruger *arg6 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (Kruger *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Kruger const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(Kruger 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 ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerZero__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerZero__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerZero__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerZero__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Kruger *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (Kruger *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Kruger const & is null", 0);
    return 0;
  } 
  arg8 = (_IterativeBootstrap *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(Kruger const &)*arg7,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerZero__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  Kruger *arg7 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (Kruger *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Kruger const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(Kruger 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 ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerZero__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerZero__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerZero__SWIG_9(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerZero__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  Kruger *arg5 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg5 = (Kruger *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Kruger const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(Kruger 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 ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerZero__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerZero__SWIG_12(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  Kruger *arg6 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg6 = (Kruger *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Kruger const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(Kruger 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 ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerZero__SWIG_13(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseKrugerZero_dates(void * jarg1) {
  void * jresult ;
  PiecewiseKrugerZero *arg1 = (PiecewiseKrugerZero *) 0 ;
  ext::shared_ptr< PiecewiseKrugerZero const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseKrugerZero > *)jarg1;
  arg1 = (PiecewiseKrugerZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseKrugerZero 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_PiecewiseKrugerZero_times(void * jarg1) {
  void * jresult ;
  PiecewiseKrugerZero *arg1 = (PiecewiseKrugerZero *) 0 ;
  ext::shared_ptr< PiecewiseKrugerZero const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseKrugerZero > *)jarg1;
  arg1 = (PiecewiseKrugerZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseKrugerZero 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseKrugerZero_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseKrugerZero *arg1 = (PiecewiseKrugerZero *) 0 ;
  ext::shared_ptr< PiecewiseKrugerZero const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseKrugerZero > *)jarg1;
  arg1 = (PiecewiseKrugerZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseKrugerZero const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PiecewiseKrugerZero_recalculate(void * jarg1) {
  PiecewiseKrugerZero *arg1 = (PiecewiseKrugerZero *) 0 ;
  ext::shared_ptr< PiecewiseKrugerZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseKrugerZero > *)jarg1;
  arg1 = (PiecewiseKrugerZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseKrugerZero_freeze(void * jarg1) {
  PiecewiseKrugerZero *arg1 = (PiecewiseKrugerZero *) 0 ;
  ext::shared_ptr< PiecewiseKrugerZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseKrugerZero > *)jarg1;
  arg1 = (PiecewiseKrugerZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseKrugerZero_unfreeze(void * jarg1) {
  PiecewiseKrugerZero *arg1 = (PiecewiseKrugerZero *) 0 ;
  ext::shared_ptr< PiecewiseKrugerZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseKrugerZero > *)jarg1;
  arg1 = (PiecewiseKrugerZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_delete_PiecewiseKrugerZero(void * jarg1) {
  PiecewiseKrugerZero *arg1 = (PiecewiseKrugerZero *) 0 ;
  ext::shared_ptr< PiecewiseKrugerZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseKrugerZero > *)jarg1;
  arg1 = (PiecewiseKrugerZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerLogDiscount__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  KrugerLog *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (KrugerLog *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KrugerLog const & is null", 0);
    return 0;
  } 
  arg7 = (_IterativeBootstrap *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(KrugerLog const &)*arg6,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerLogDiscount__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  KrugerLog *arg6 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (KrugerLog *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KrugerLog const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(KrugerLog 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 ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerLogDiscount__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerLogDiscount__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerLogDiscount__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerLogDiscount__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  KrugerLog *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (KrugerLog *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KrugerLog const & is null", 0);
    return 0;
  } 
  arg8 = (_IterativeBootstrap *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(KrugerLog const &)*arg7,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerLogDiscount__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  KrugerLog *arg7 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (KrugerLog *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KrugerLog const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(KrugerLog 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 ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerLogDiscount__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerLogDiscount__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerLogDiscount__SWIG_9(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerLogDiscount__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  KrugerLog *arg5 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg5 = (KrugerLog *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KrugerLog const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(KrugerLog 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 ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerLogDiscount__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerLogDiscount__SWIG_12(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  KrugerLog *arg6 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg6 = (KrugerLog *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KrugerLog const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(KrugerLog 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 ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseKrugerLogDiscount__SWIG_13(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseKrugerLogDiscount_dates(void * jarg1) {
  void * jresult ;
  PiecewiseKrugerLogDiscount *arg1 = (PiecewiseKrugerLogDiscount *) 0 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseKrugerLogDiscount > *)jarg1;
  arg1 = (PiecewiseKrugerLogDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseKrugerLogDiscount 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_PiecewiseKrugerLogDiscount_times(void * jarg1) {
  void * jresult ;
  PiecewiseKrugerLogDiscount *arg1 = (PiecewiseKrugerLogDiscount *) 0 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseKrugerLogDiscount > *)jarg1;
  arg1 = (PiecewiseKrugerLogDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseKrugerLogDiscount 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseKrugerLogDiscount_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseKrugerLogDiscount *arg1 = (PiecewiseKrugerLogDiscount *) 0 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseKrugerLogDiscount > *)jarg1;
  arg1 = (PiecewiseKrugerLogDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseKrugerLogDiscount const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PiecewiseKrugerLogDiscount_recalculate(void * jarg1) {
  PiecewiseKrugerLogDiscount *arg1 = (PiecewiseKrugerLogDiscount *) 0 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseKrugerLogDiscount > *)jarg1;
  arg1 = (PiecewiseKrugerLogDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseKrugerLogDiscount_freeze(void * jarg1) {
  PiecewiseKrugerLogDiscount *arg1 = (PiecewiseKrugerLogDiscount *) 0 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseKrugerLogDiscount > *)jarg1;
  arg1 = (PiecewiseKrugerLogDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseKrugerLogDiscount_unfreeze(void * jarg1) {
  PiecewiseKrugerLogDiscount *arg1 = (PiecewiseKrugerLogDiscount *) 0 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseKrugerLogDiscount > *)jarg1;
  arg1 = (PiecewiseKrugerLogDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_delete_PiecewiseKrugerLogDiscount(void * jarg1) {
  PiecewiseKrugerLogDiscount *arg1 = (PiecewiseKrugerLogDiscount *) 0 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseKrugerLogDiscount > *)jarg1;
  arg1 = (PiecewiseKrugerLogDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneForward__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  ConvexMonotone *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (ConvexMonotone *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ConvexMonotone const & is null", 0);
    return 0;
  } 
  arg7 = (_IterativeBootstrap *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(ConvexMonotone const &)*arg6,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneForward__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  ConvexMonotone *arg6 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (ConvexMonotone *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ConvexMonotone const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(ConvexMonotone 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 ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneForward__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneForward__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneForward__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneForward__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  ConvexMonotone *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (ConvexMonotone *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ConvexMonotone const & is null", 0);
    return 0;
  } 
  arg8 = (_IterativeBootstrap *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(ConvexMonotone const &)*arg7,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneForward__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  ConvexMonotone *arg7 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (ConvexMonotone *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ConvexMonotone const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(ConvexMonotone 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 ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneForward__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneForward__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneForward__SWIG_9(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneForward__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  ConvexMonotone *arg5 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg5 = (ConvexMonotone *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ConvexMonotone const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(ConvexMonotone 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 ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneForward__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneForward__SWIG_12(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  ConvexMonotone *arg6 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg6 = (ConvexMonotone *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ConvexMonotone const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(ConvexMonotone 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 ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneForward__SWIG_13(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseConvexMonotoneForward_dates(void * jarg1) {
  void * jresult ;
  PiecewiseConvexMonotoneForward *arg1 = (PiecewiseConvexMonotoneForward *) 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseConvexMonotoneForward > *)jarg1;
  arg1 = (PiecewiseConvexMonotoneForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseConvexMonotoneForward 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_PiecewiseConvexMonotoneForward_times(void * jarg1) {
  void * jresult ;
  PiecewiseConvexMonotoneForward *arg1 = (PiecewiseConvexMonotoneForward *) 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseConvexMonotoneForward > *)jarg1;
  arg1 = (PiecewiseConvexMonotoneForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseConvexMonotoneForward 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseConvexMonotoneForward_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseConvexMonotoneForward *arg1 = (PiecewiseConvexMonotoneForward *) 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseConvexMonotoneForward > *)jarg1;
  arg1 = (PiecewiseConvexMonotoneForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseConvexMonotoneForward const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PiecewiseConvexMonotoneForward_recalculate(void * jarg1) {
  PiecewiseConvexMonotoneForward *arg1 = (PiecewiseConvexMonotoneForward *) 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseConvexMonotoneForward > *)jarg1;
  arg1 = (PiecewiseConvexMonotoneForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseConvexMonotoneForward_freeze(void * jarg1) {
  PiecewiseConvexMonotoneForward *arg1 = (PiecewiseConvexMonotoneForward *) 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseConvexMonotoneForward > *)jarg1;
  arg1 = (PiecewiseConvexMonotoneForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseConvexMonotoneForward_unfreeze(void * jarg1) {
  PiecewiseConvexMonotoneForward *arg1 = (PiecewiseConvexMonotoneForward *) 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseConvexMonotoneForward > *)jarg1;
  arg1 = (PiecewiseConvexMonotoneForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_delete_PiecewiseConvexMonotoneForward(void * jarg1) {
  PiecewiseConvexMonotoneForward *arg1 = (PiecewiseConvexMonotoneForward *) 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseConvexMonotoneForward > *)jarg1;
  arg1 = (PiecewiseConvexMonotoneForward *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneZero__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  ConvexMonotone *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (ConvexMonotone *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ConvexMonotone const & is null", 0);
    return 0;
  } 
  arg7 = (_IterativeBootstrap *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(ConvexMonotone const &)*arg6,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneZero__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  ConvexMonotone *arg6 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (ConvexMonotone *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ConvexMonotone const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(ConvexMonotone 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 ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneZero__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneZero__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneZero__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneZero__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  ConvexMonotone *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (ConvexMonotone *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ConvexMonotone const & is null", 0);
    return 0;
  } 
  arg8 = (_IterativeBootstrap *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(ConvexMonotone const &)*arg7,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneZero__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  ConvexMonotone *arg7 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (ConvexMonotone *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ConvexMonotone const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(ConvexMonotone 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 ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneZero__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneZero__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneZero__SWIG_9(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneZero__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  ConvexMonotone *arg5 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg5 = (ConvexMonotone *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ConvexMonotone const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(ConvexMonotone 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 ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneZero__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneZero__SWIG_12(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  ConvexMonotone *arg6 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg6 = (ConvexMonotone *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ConvexMonotone const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(ConvexMonotone 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 ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseConvexMonotoneZero__SWIG_13(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseConvexMonotoneZero_dates(void * jarg1) {
  void * jresult ;
  PiecewiseConvexMonotoneZero *arg1 = (PiecewiseConvexMonotoneZero *) 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseConvexMonotoneZero > *)jarg1;
  arg1 = (PiecewiseConvexMonotoneZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseConvexMonotoneZero 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_PiecewiseConvexMonotoneZero_times(void * jarg1) {
  void * jresult ;
  PiecewiseConvexMonotoneZero *arg1 = (PiecewiseConvexMonotoneZero *) 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseConvexMonotoneZero > *)jarg1;
  arg1 = (PiecewiseConvexMonotoneZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseConvexMonotoneZero 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseConvexMonotoneZero_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseConvexMonotoneZero *arg1 = (PiecewiseConvexMonotoneZero *) 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseConvexMonotoneZero > *)jarg1;
  arg1 = (PiecewiseConvexMonotoneZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseConvexMonotoneZero const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PiecewiseConvexMonotoneZero_recalculate(void * jarg1) {
  PiecewiseConvexMonotoneZero *arg1 = (PiecewiseConvexMonotoneZero *) 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseConvexMonotoneZero > *)jarg1;
  arg1 = (PiecewiseConvexMonotoneZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseConvexMonotoneZero_freeze(void * jarg1) {
  PiecewiseConvexMonotoneZero *arg1 = (PiecewiseConvexMonotoneZero *) 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseConvexMonotoneZero > *)jarg1;
  arg1 = (PiecewiseConvexMonotoneZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseConvexMonotoneZero_unfreeze(void * jarg1) {
  PiecewiseConvexMonotoneZero *arg1 = (PiecewiseConvexMonotoneZero *) 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseConvexMonotoneZero > *)jarg1;
  arg1 = (PiecewiseConvexMonotoneZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_delete_PiecewiseConvexMonotoneZero(void * jarg1) {
  PiecewiseConvexMonotoneZero *arg1 = (PiecewiseConvexMonotoneZero *) 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseConvexMonotoneZero > *)jarg1;
  arg1 = (PiecewiseConvexMonotoneZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalCubicZero__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (SplineCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg7 = (_IterativeBootstrap *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(SplineCubic const &)*arg6,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalCubicZero__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (SplineCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(SplineCubic 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 ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalCubicZero__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalCubicZero__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalCubicZero__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalCubicZero__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  SplineCubic *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (SplineCubic *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg8 = (_IterativeBootstrap *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(SplineCubic const &)*arg7,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalCubicZero__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  SplineCubic *arg7 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (SplineCubic *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(SplineCubic 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 ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalCubicZero__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalCubicZero__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalCubicZero__SWIG_9(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalCubicZero__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  SplineCubic *arg5 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg5 = (SplineCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(SplineCubic 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 ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalCubicZero__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalCubicZero__SWIG_12(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg6 = (SplineCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(SplineCubic 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 ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalCubicZero__SWIG_13(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseNaturalCubicZero_dates(void * jarg1) {
  void * jresult ;
  PiecewiseNaturalCubicZero *arg1 = (PiecewiseNaturalCubicZero *) 0 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseNaturalCubicZero > *)jarg1;
  arg1 = (PiecewiseNaturalCubicZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseNaturalCubicZero 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_PiecewiseNaturalCubicZero_times(void * jarg1) {
  void * jresult ;
  PiecewiseNaturalCubicZero *arg1 = (PiecewiseNaturalCubicZero *) 0 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseNaturalCubicZero > *)jarg1;
  arg1 = (PiecewiseNaturalCubicZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseNaturalCubicZero 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseNaturalCubicZero_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseNaturalCubicZero *arg1 = (PiecewiseNaturalCubicZero *) 0 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseNaturalCubicZero > *)jarg1;
  arg1 = (PiecewiseNaturalCubicZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseNaturalCubicZero const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PiecewiseNaturalCubicZero_recalculate(void * jarg1) {
  PiecewiseNaturalCubicZero *arg1 = (PiecewiseNaturalCubicZero *) 0 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseNaturalCubicZero > *)jarg1;
  arg1 = (PiecewiseNaturalCubicZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseNaturalCubicZero_freeze(void * jarg1) {
  PiecewiseNaturalCubicZero *arg1 = (PiecewiseNaturalCubicZero *) 0 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseNaturalCubicZero > *)jarg1;
  arg1 = (PiecewiseNaturalCubicZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseNaturalCubicZero_unfreeze(void * jarg1) {
  PiecewiseNaturalCubicZero *arg1 = (PiecewiseNaturalCubicZero *) 0 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseNaturalCubicZero > *)jarg1;
  arg1 = (PiecewiseNaturalCubicZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_delete_PiecewiseNaturalCubicZero(void * jarg1) {
  PiecewiseNaturalCubicZero *arg1 = (PiecewiseNaturalCubicZero *) 0 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseNaturalCubicZero > *)jarg1;
  arg1 = (PiecewiseNaturalCubicZero *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalLogCubicDiscount__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  SplineLogCubic *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (SplineLogCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineLogCubic const & is null", 0);
    return 0;
  } 
  arg7 = (_IterativeBootstrap *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(SplineLogCubic const &)*arg6,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalLogCubicDiscount__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  SplineLogCubic *arg6 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (SplineLogCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineLogCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(SplineLogCubic 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 ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalLogCubicDiscount__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalLogCubicDiscount__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalLogCubicDiscount__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalLogCubicDiscount__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  SplineLogCubic *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (SplineLogCubic *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineLogCubic const & is null", 0);
    return 0;
  } 
  arg8 = (_IterativeBootstrap *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(SplineLogCubic const &)*arg7,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalLogCubicDiscount__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  SplineLogCubic *arg7 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (SplineLogCubic *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineLogCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(SplineLogCubic 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 ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalLogCubicDiscount__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalLogCubicDiscount__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalLogCubicDiscount__SWIG_9(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalLogCubicDiscount__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  SplineLogCubic *arg5 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg5 = (SplineLogCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineLogCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(SplineLogCubic 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 ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalLogCubicDiscount__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalLogCubicDiscount__SWIG_12(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  SplineLogCubic *arg6 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg6 = (SplineLogCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineLogCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(SplineLogCubic 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 ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseNaturalLogCubicDiscount__SWIG_13(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseNaturalLogCubicDiscount_dates(void * jarg1) {
  void * jresult ;
  PiecewiseNaturalLogCubicDiscount *arg1 = (PiecewiseNaturalLogCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseNaturalLogCubicDiscount > *)jarg1;
  arg1 = (PiecewiseNaturalLogCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseNaturalLogCubicDiscount 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_PiecewiseNaturalLogCubicDiscount_times(void * jarg1) {
  void * jresult ;
  PiecewiseNaturalLogCubicDiscount *arg1 = (PiecewiseNaturalLogCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseNaturalLogCubicDiscount > *)jarg1;
  arg1 = (PiecewiseNaturalLogCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseNaturalLogCubicDiscount 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseNaturalLogCubicDiscount_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseNaturalLogCubicDiscount *arg1 = (PiecewiseNaturalLogCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseNaturalLogCubicDiscount > *)jarg1;
  arg1 = (PiecewiseNaturalLogCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseNaturalLogCubicDiscount const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PiecewiseNaturalLogCubicDiscount_recalculate(void * jarg1) {
  PiecewiseNaturalLogCubicDiscount *arg1 = (PiecewiseNaturalLogCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *)jarg1;
  arg1 = (PiecewiseNaturalLogCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseNaturalLogCubicDiscount_freeze(void * jarg1) {
  PiecewiseNaturalLogCubicDiscount *arg1 = (PiecewiseNaturalLogCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *)jarg1;
  arg1 = (PiecewiseNaturalLogCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseNaturalLogCubicDiscount_unfreeze(void * jarg1) {
  PiecewiseNaturalLogCubicDiscount *arg1 = (PiecewiseNaturalLogCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *)jarg1;
  arg1 = (PiecewiseNaturalLogCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_delete_PiecewiseNaturalLogCubicDiscount(void * jarg1) {
  PiecewiseNaturalLogCubicDiscount *arg1 = (PiecewiseNaturalLogCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *)jarg1;
  arg1 = (PiecewiseNaturalLogCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  LogMixedLinearCubic *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (LogMixedLinearCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogMixedLinearCubic const & is null", 0);
    return 0;
  } 
  arg7 = (_IterativeBootstrap *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(LogMixedLinearCubic const &)*arg6,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  LogMixedLinearCubic *arg6 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (LogMixedLinearCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogMixedLinearCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote > > const &)*arg4,(std::vector< Date > const &)*arg5,(LogMixedLinearCubic 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 ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  std::vector< Date > *arg5 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote > > *arg4 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_5(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  LogMixedLinearCubic *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (LogMixedLinearCubic *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogMixedLinearCubic const & is null", 0);
    return 0;
  } 
  arg8 = (_IterativeBootstrap *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(LogMixedLinearCubic const &)*arg7,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_6(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  LogMixedLinearCubic *arg7 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (LogMixedLinearCubic *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogMixedLinearCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote > > const &)*arg5,(std::vector< Date > const &)*arg6,(LogMixedLinearCubic 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 ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_8(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote > > *arg5 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Handle< Quote > > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_9(int jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_10(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  LogMixedLinearCubic *arg5 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg5 = (LogMixedLinearCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogMixedLinearCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(LogMixedLinearCubic 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 ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_11(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_12(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  LogMixedLinearCubic *arg6 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  arg6 = (LogMixedLinearCubic *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogMixedLinearCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(LogMixedLinearCubic 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 ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_13(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLogMixedLinearCubicDiscount_dates(void * jarg1) {
  void * jresult ;
  PiecewiseLogMixedLinearCubicDiscount *arg1 = (PiecewiseLogMixedLinearCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseLogMixedLinearCubicDiscount > *)jarg1;
  arg1 = (PiecewiseLogMixedLinearCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseLogMixedLinearCubicDiscount 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_PiecewiseLogMixedLinearCubicDiscount_times(void * jarg1) {
  void * jresult ;
  PiecewiseLogMixedLinearCubicDiscount *arg1 = (PiecewiseLogMixedLinearCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseLogMixedLinearCubicDiscount > *)jarg1;
  arg1 = (PiecewiseLogMixedLinearCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseLogMixedLinearCubicDiscount 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseLogMixedLinearCubicDiscount_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseLogMixedLinearCubicDiscount *arg1 = (PiecewiseLogMixedLinearCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseLogMixedLinearCubicDiscount > *)jarg1;
  arg1 = (PiecewiseLogMixedLinearCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseLogMixedLinearCubicDiscount const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_PiecewiseLogMixedLinearCubicDiscount_recalculate(void * jarg1) {
  PiecewiseLogMixedLinearCubicDiscount *arg1 = (PiecewiseLogMixedLinearCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *)jarg1;
  arg1 = (PiecewiseLogMixedLinearCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseLogMixedLinearCubicDiscount_freeze(void * jarg1) {
  PiecewiseLogMixedLinearCubicDiscount *arg1 = (PiecewiseLogMixedLinearCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *)jarg1;
  arg1 = (PiecewiseLogMixedLinearCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_PiecewiseLogMixedLinearCubicDiscount_unfreeze(void * jarg1) {
  PiecewiseLogMixedLinearCubicDiscount *arg1 = (PiecewiseLogMixedLinearCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *)jarg1;
  arg1 = (PiecewiseLogMixedLinearCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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_delete_PiecewiseLogMixedLinearCubicDiscount(void * jarg1) {
  PiecewiseLogMixedLinearCubicDiscount *arg1 = (PiecewiseLogMixedLinearCubicDiscount *) 0 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *)jarg1;
  arg1 = (PiecewiseLogMixedLinearCubicDiscount *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GlobalBootstrap__SWIG_2(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = 0 ;
  std::vector< Date > *arg2 = 0 ;
  doubleOrNull arg3 ;
  _GlobalBootstrap *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg3 = (doubleOrNull)jarg3; 
  {
    try {
      result = (_GlobalBootstrap *)new _GlobalBootstrap((std::vector< ext::shared_ptr< RateHelper > > const &)*arg1,(std::vector< 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_GlobalBootstrap__SWIG_3(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = 0 ;
  std::vector< Date > *arg2 = 0 ;
  _GlobalBootstrap *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (_GlobalBootstrap *)new _GlobalBootstrap((std::vector< ext::shared_ptr< RateHelper > > const &)*arg1,(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 = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GlobalLinearSimpleZeroCurve(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _GlobalBootstrap *arg4 = 0 ;
  GlobalLinearSimpleZeroCurve *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< RateHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< RateHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_GlobalBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_GlobalBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (GlobalLinearSimpleZeroCurve *)new_GlobalLinearSimpleZeroCurve((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper > > const &)*arg2,(DayCounter const &)*arg3,(_GlobalBootstrap 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 ? new ext::shared_ptr<  GlobalLinearSimpleZeroCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GlobalLinearSimpleZeroCurve_dates(void * jarg1) {
  void * jresult ;
  GlobalLinearSimpleZeroCurve *arg1 = (GlobalLinearSimpleZeroCurve *) 0 ;
  ext::shared_ptr< GlobalLinearSimpleZeroCurve const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const GlobalLinearSimpleZeroCurve > *)jarg1;
  arg1 = (GlobalLinearSimpleZeroCurve *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((GlobalLinearSimpleZeroCurve 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_GlobalLinearSimpleZeroCurve_times(void * jarg1) {
  void * jresult ;
  GlobalLinearSimpleZeroCurve *arg1 = (GlobalLinearSimpleZeroCurve *) 0 ;
  ext::shared_ptr< GlobalLinearSimpleZeroCurve const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const GlobalLinearSimpleZeroCurve > *)jarg1;
  arg1 = (GlobalLinearSimpleZeroCurve *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((GlobalLinearSimpleZeroCurve 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GlobalLinearSimpleZeroCurve_nodes(void * jarg1) {
  void * jresult ;
  GlobalLinearSimpleZeroCurve *arg1 = (GlobalLinearSimpleZeroCurve *) 0 ;
  ext::shared_ptr< GlobalLinearSimpleZeroCurve const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const GlobalLinearSimpleZeroCurve > *)jarg1;
  arg1 = (GlobalLinearSimpleZeroCurve *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((GlobalLinearSimpleZeroCurve const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GlobalLinearSimpleZeroCurve(void * jarg1) {
  GlobalLinearSimpleZeroCurve *arg1 = (GlobalLinearSimpleZeroCurve *) 0 ;
  ext::shared_ptr< GlobalLinearSimpleZeroCurve > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GlobalLinearSimpleZeroCurve > *)jarg1;
  arg1 = (GlobalLinearSimpleZeroCurve *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_DefaultProbabilityTermStructure_defaultProbability__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  double jresult ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Probability result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Probability result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  bool arg3 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Probability result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Probability result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Probability result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Probability result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  bool arg4 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Probability result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Probability result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Probability result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Probability result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  bool arg3 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Probability result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Probability result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  bool arg3 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  bool arg3 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  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_delete_DefaultProbabilityTermStructure(void * jarg1) {
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityTermStructure > *)jarg1;
  arg1 = (DefaultProbabilityTermStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DefaultProbabilityTermStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *arg1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempnull1 ;
  Handle< DefaultProbabilityTermStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< DefaultProbabilityTermStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Handle< DefaultProbabilityTermStructure > *)new Handle< DefaultProbabilityTermStructure >((ext::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 ;
  ext::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 = result ? new ext::shared_ptr< DefaultProbabilityTermStructure >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_currentLink(void * jarg1) {
  void * jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< DefaultProbabilityTermStructure >(result) : 0; 
  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 ;
  ext::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 = result ? new ext::shared_ptr< Observable >(result) : 0; 
  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 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 & 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 & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & 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 & 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 & 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 & 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 & 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 & 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_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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructureHandle_timeFromReference(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time result;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)(*arg1)->timeFromReference((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_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(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(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(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 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 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *arg1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempnull1 ;
  RelinkableHandle< DefaultProbabilityTermStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< DefaultProbabilityTermStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (RelinkableHandle< DefaultProbabilityTermStructure > *)new RelinkableHandle< DefaultProbabilityTermStructure >((ext::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 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *arg2 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempnull2 ;
  
  arg1 = (RelinkableHandle< DefaultProbabilityTermStructure > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< DefaultProbabilityTermStructure > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->linkTo((ext::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_RelinkableDefaultProbabilityTermStructureHandle_reset(void * jarg1) {
  RelinkableHandle< DefaultProbabilityTermStructure > *arg1 = (RelinkableHandle< DefaultProbabilityTermStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< DefaultProbabilityTermStructure > *)jarg1; 
  {
    try {
      RelinkableHandle_Sl_DefaultProbabilityTermStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  FlatHazardRate *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FlatHazardRate *)new FlatHazardRate(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 = result ? new ext::shared_ptr<  FlatHazardRate >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  FlatHazardRate *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FlatHazardRate *)new FlatHazardRate((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 = result ? new ext::shared_ptr<  FlatHazardRate >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FlatHazardRate(void * jarg1) {
  FlatHazardRate *arg1 = (FlatHazardRate *) 0 ;
  ext::shared_ptr< FlatHazardRate > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FlatHazardRate > *)jarg1;
  arg1 = (FlatHazardRate *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  InterpolatedHazardRateCurve< BackwardFlat > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (BackwardFlat *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedHazardRateCurve< BackwardFlat > *)new InterpolatedHazardRateCurve< BackwardFlat >((std::vector< Date > const &)*arg1,(std::vector< Real > 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 = result ? new ext::shared_ptr<  InterpolatedHazardRateCurve<BackwardFlat> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedHazardRateCurve< BackwardFlat > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedHazardRateCurve< BackwardFlat > *)new InterpolatedHazardRateCurve< BackwardFlat >((std::vector< Date > const &)*arg1,(std::vector< Real > 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 = result ? new ext::shared_ptr<  InterpolatedHazardRateCurve<BackwardFlat> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedHazardRateCurve< BackwardFlat > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedHazardRateCurve< BackwardFlat > *)new InterpolatedHazardRateCurve< BackwardFlat >((std::vector< Date > const &)*arg1,(std::vector< Real > 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 = result ? new ext::shared_ptr<  InterpolatedHazardRateCurve<BackwardFlat> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HazardRateCurve_dates(void * jarg1) {
  void * jresult ;
  InterpolatedHazardRateCurve< BackwardFlat > *arg1 = (InterpolatedHazardRateCurve< BackwardFlat > *) 0 ;
  ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedHazardRateCurve<BackwardFlat> > *)jarg1;
  arg1 = (InterpolatedHazardRateCurve<BackwardFlat> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedHazardRateCurve< BackwardFlat > 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_HazardRateCurve_hazardRates(void * jarg1) {
  void * jresult ;
  InterpolatedHazardRateCurve< BackwardFlat > *arg1 = (InterpolatedHazardRateCurve< BackwardFlat > *) 0 ;
  ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedHazardRateCurve<BackwardFlat> > *)jarg1;
  arg1 = (InterpolatedHazardRateCurve<BackwardFlat> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedHazardRateCurve< BackwardFlat > const *)arg1)->hazardRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  InterpolatedHazardRateCurve< BackwardFlat > *arg1 = (InterpolatedHazardRateCurve< BackwardFlat > *) 0 ;
  ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedHazardRateCurve<BackwardFlat> > *)jarg1;
  arg1 = (InterpolatedHazardRateCurve<BackwardFlat> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedHazardRateCurve< BackwardFlat > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HazardRateCurve(void * jarg1) {
  InterpolatedHazardRateCurve< BackwardFlat > *arg1 = (InterpolatedHazardRateCurve< BackwardFlat > *) 0 ;
  ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedHazardRateCurve<BackwardFlat> > *)jarg1;
  arg1 = (InterpolatedHazardRateCurve<BackwardFlat> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  InterpolatedDefaultDensityCurve< Linear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDefaultDensityCurve< Linear > *)new InterpolatedDefaultDensityCurve< Linear >((std::vector< Date > const &)*arg1,(std::vector< Real > 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 = result ? new ext::shared_ptr<  InterpolatedDefaultDensityCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedDefaultDensityCurve< Linear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDefaultDensityCurve< Linear > *)new InterpolatedDefaultDensityCurve< Linear >((std::vector< Date > const &)*arg1,(std::vector< Real > 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 = result ? new ext::shared_ptr<  InterpolatedDefaultDensityCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedDefaultDensityCurve< Linear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDefaultDensityCurve< Linear > *)new InterpolatedDefaultDensityCurve< Linear >((std::vector< Date > const &)*arg1,(std::vector< Real > 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 = result ? new ext::shared_ptr<  InterpolatedDefaultDensityCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultDensityCurve_dates(void * jarg1) {
  void * jresult ;
  InterpolatedDefaultDensityCurve< Linear > *arg1 = (InterpolatedDefaultDensityCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDefaultDensityCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedDefaultDensityCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedDefaultDensityCurve< Linear > 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_DefaultDensityCurve_defaultDensities(void * jarg1) {
  void * jresult ;
  InterpolatedDefaultDensityCurve< Linear > *arg1 = (InterpolatedDefaultDensityCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDefaultDensityCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedDefaultDensityCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedDefaultDensityCurve< Linear > const *)arg1)->defaultDensities();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  InterpolatedDefaultDensityCurve< Linear > *arg1 = (InterpolatedDefaultDensityCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDefaultDensityCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedDefaultDensityCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedDefaultDensityCurve< Linear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DefaultDensityCurve(void * jarg1) {
  InterpolatedDefaultDensityCurve< Linear > *arg1 = (InterpolatedDefaultDensityCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedDefaultDensityCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedDefaultDensityCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SurvivalProbabilityCurve__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Probability > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Linear *arg5 = 0 ;
  InterpolatedSurvivalProbabilityCurve< Linear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Probability > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Probability > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSurvivalProbabilityCurve< Linear > *)new InterpolatedSurvivalProbabilityCurve< Linear >((std::vector< Date > const &)*arg1,(std::vector< Probability > 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 = result ? new ext::shared_ptr<  InterpolatedSurvivalProbabilityCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SurvivalProbabilityCurve__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Probability > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  InterpolatedSurvivalProbabilityCurve< Linear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Probability > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Probability > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSurvivalProbabilityCurve< Linear > *)new InterpolatedSurvivalProbabilityCurve< Linear >((std::vector< Date > const &)*arg1,(std::vector< Probability > 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 = result ? new ext::shared_ptr<  InterpolatedSurvivalProbabilityCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SurvivalProbabilityCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Probability > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  InterpolatedSurvivalProbabilityCurve< Linear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Probability > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Probability > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedSurvivalProbabilityCurve< Linear > *)new InterpolatedSurvivalProbabilityCurve< Linear >((std::vector< Date > const &)*arg1,(std::vector< Probability > 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 = result ? new ext::shared_ptr<  InterpolatedSurvivalProbabilityCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SurvivalProbabilityCurve_dates(void * jarg1) {
  void * jresult ;
  InterpolatedSurvivalProbabilityCurve< Linear > *arg1 = (InterpolatedSurvivalProbabilityCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedSurvivalProbabilityCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedSurvivalProbabilityCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedSurvivalProbabilityCurve< Linear > 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_SurvivalProbabilityCurve_survivalProbabilities(void * jarg1) {
  void * jresult ;
  InterpolatedSurvivalProbabilityCurve< Linear > *arg1 = (InterpolatedSurvivalProbabilityCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Probability > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedSurvivalProbabilityCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedSurvivalProbabilityCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Probability > *) &((InterpolatedSurvivalProbabilityCurve< Linear > const *)arg1)->survivalProbabilities();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SurvivalProbabilityCurve_nodes(void * jarg1) {
  void * jresult ;
  InterpolatedSurvivalProbabilityCurve< Linear > *arg1 = (InterpolatedSurvivalProbabilityCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedSurvivalProbabilityCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedSurvivalProbabilityCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedSurvivalProbabilityCurve< Linear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SurvivalProbabilityCurve(void * jarg1) {
  InterpolatedSurvivalProbabilityCurve< Linear > *arg1 = (InterpolatedSurvivalProbabilityCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedSurvivalProbabilityCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedSurvivalProbabilityCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_quote(void * jarg1) {
  void * jresult ;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  ext::shared_ptr< DefaultProbabilityHelper const > *smartarg1 = 0 ;
  Handle< Quote > result;
  
  
  smartarg1 = (ext::shared_ptr< const DefaultProbabilityHelper > *)jarg1;
  arg1 = (DefaultProbabilityHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((DefaultProbabilityHelper const *)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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelper_latestDate(void * jarg1) {
  void * jresult ;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  ext::shared_ptr< DefaultProbabilityHelper const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const DefaultProbabilityHelper > *)jarg1;
  arg1 = (DefaultProbabilityHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((DefaultProbabilityHelper const *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelper_earliestDate(void * jarg1) {
  void * jresult ;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  ext::shared_ptr< DefaultProbabilityHelper const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const DefaultProbabilityHelper > *)jarg1;
  arg1 = (DefaultProbabilityHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((DefaultProbabilityHelper const *)arg1)->earliestDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelper_maturityDate(void * jarg1) {
  void * jresult ;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  ext::shared_ptr< DefaultProbabilityHelper const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const DefaultProbabilityHelper > *)jarg1;
  arg1 = (DefaultProbabilityHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((DefaultProbabilityHelper const *)arg1)->maturityDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelper_latestRelevantDate(void * jarg1) {
  void * jresult ;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  ext::shared_ptr< DefaultProbabilityHelper const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const DefaultProbabilityHelper > *)jarg1;
  arg1 = (DefaultProbabilityHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((DefaultProbabilityHelper const *)arg1)->latestRelevantDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelper_pillarDate(void * jarg1) {
  void * jresult ;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  ext::shared_ptr< DefaultProbabilityHelper const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const DefaultProbabilityHelper > *)jarg1;
  arg1 = (DefaultProbabilityHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((DefaultProbabilityHelper const *)arg1)->pillarDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelper_impliedQuote(void * jarg1) {
  double jresult ;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  ext::shared_ptr< DefaultProbabilityHelper const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const DefaultProbabilityHelper > *)jarg1;
  arg1 = (DefaultProbabilityHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((DefaultProbabilityHelper const *)arg1)->impliedQuote();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelper_quoteError(void * jarg1) {
  double jresult ;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  ext::shared_ptr< DefaultProbabilityHelper const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const DefaultProbabilityHelper > *)jarg1;
  arg1 = (DefaultProbabilityHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((DefaultProbabilityHelper const *)arg1)->quoteError();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_DefaultProbabilityHelper(void * jarg1) {
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  ext::shared_ptr< DefaultProbabilityHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultProbabilityHelper > *)jarg1;
  arg1 = (DefaultProbabilityHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  
  arg1 = (std::vector< ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  ext::shared_ptr< DefaultProbabilityHelper > *arg2 = 0 ;
  ext::shared_ptr< DefaultProbabilityHelper > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< DefaultProbabilityHelper > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (std::vector< ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)new std::vector< ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)new std::vector< ext::shared_ptr< DefaultProbabilityHelper > >((std::vector< ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)new_std_vector_Sl_ext_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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< DefaultProbabilityHelper > result;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_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 = result ? new ext::shared_ptr< DefaultProbabilityHelper >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type *) &std_vector_Sl_ext_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 = *result ? new std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelperVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< DefaultProbabilityHelper > *arg3 = 0 ;
  ext::shared_ptr< DefaultProbabilityHelper > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< DefaultProbabilityHelper > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__setitem(arg1,arg2,(ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__AddRange(arg1,(std::vector< ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)std_vector_Sl_ext_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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< DefaultProbabilityHelper > *arg3 = 0 ;
  ext::shared_ptr< DefaultProbabilityHelper > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< DefaultProbabilityHelper > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Insert(arg1,arg2,(ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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 ;
  ext::shared_ptr< DefaultProbabilityHelper > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< DefaultProbabilityHelper > tempnull1 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< DefaultProbabilityHelper > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Repeat((ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  ext::shared_ptr< DefaultProbabilityHelper > *arg2 = 0 ;
  ext::shared_ptr< DefaultProbabilityHelper > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< DefaultProbabilityHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Contains(arg1,(ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  ext::shared_ptr< DefaultProbabilityHelper > *arg2 = 0 ;
  ext::shared_ptr< DefaultProbabilityHelper > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< DefaultProbabilityHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__IndexOf(arg1,(ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  ext::shared_ptr< DefaultProbabilityHelper > *arg2 = 0 ;
  ext::shared_ptr< DefaultProbabilityHelper > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< DefaultProbabilityHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__LastIndexOf(arg1,(ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  ext::shared_ptr< DefaultProbabilityHelper > *arg2 = 0 ;
  ext::shared_ptr< DefaultProbabilityHelper > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< DefaultProbabilityHelper > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__Remove(arg1,(ext::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< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  
  arg1 = (std::vector< ext::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 * jarg13, void * jarg14, unsigned int jarg15, int jarg16) {
  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 ;
  Date *arg13 = 0 ;
  DayCounter *arg14 = 0 ;
  bool arg15 ;
  CreditDefaultSwap::PricingModel arg16 ;
  SpreadCdsHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (DayCounter *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg15 = jarg15 ? true : false; 
  arg16 = (CreditDefaultSwap::PricingModel)jarg16; 
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,(Date const &)*arg13,(DayCounter const &)*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 = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, unsigned int jarg12, void * jarg13, void * jarg14, unsigned int jarg15) {
  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 ;
  Date *arg13 = 0 ;
  DayCounter *arg14 = 0 ;
  bool arg15 ;
  SpreadCdsHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (DayCounter *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,(Date const &)*arg13,(DayCounter const &)*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 = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, unsigned int jarg11, unsigned int jarg12, void * jarg13, void * jarg14) {
  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 ;
  Date *arg13 = 0 ;
  DayCounter *arg14 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (DayCounter *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,(Date const &)*arg13,(DayCounter 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 = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_3(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 * jarg13) {
  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 ;
  Date *arg13 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,(Date 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 = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_4(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 ;
  SpreadCdsHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper((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 = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_5(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 ;
  SpreadCdsHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper((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 = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_6(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 ;
  SpreadCdsHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper((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 = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_7(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 * jarg13, void * jarg14, unsigned int jarg15, int jarg16) {
  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 ;
  Date *arg13 = 0 ;
  DayCounter *arg14 = 0 ;
  bool arg15 ;
  CreditDefaultSwap::PricingModel arg16 ;
  SpreadCdsHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (DayCounter *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg15 = jarg15 ? true : false; 
  arg16 = (CreditDefaultSwap::PricingModel)jarg16; 
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper(arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,(Date const &)*arg13,(DayCounter const &)*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 = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_8(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 * jarg13, void * jarg14, unsigned int jarg15) {
  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 ;
  Date *arg13 = 0 ;
  DayCounter *arg14 = 0 ;
  bool arg15 ;
  SpreadCdsHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (DayCounter *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg15 = jarg15 ? true : false; 
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper(arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,(Date const &)*arg13,(DayCounter const &)*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 = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_9(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 * jarg13, void * jarg14) {
  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 ;
  Date *arg13 = 0 ;
  DayCounter *arg14 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (DayCounter *)jarg14;
  if (!arg14) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper(arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,(Date const &)*arg13,(DayCounter 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 = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_10(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 * jarg13) {
  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 ;
  Date *arg13 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper(arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,(Date 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 = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_11(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 ;
  SpreadCdsHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper(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 = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_12(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 ;
  SpreadCdsHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? true : false; 
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper(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 = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadCdsHelper__SWIG_13(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 ;
  SpreadCdsHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg3 = (Integer)jarg3; 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  arg10 = (Handle< YieldTermStructure > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper(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 = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SpreadCdsHelper(void * jarg1) {
  SpreadCdsHelper *arg1 = (SpreadCdsHelper *) 0 ;
  ext::shared_ptr< SpreadCdsHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SpreadCdsHelper > *)jarg1;
  arg1 = (SpreadCdsHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 * jarg15, void * jarg16, unsigned int jarg17, int jarg18) {
  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 ;
  Date *arg15 = 0 ;
  DayCounter *arg16 = 0 ;
  bool arg17 ;
  CreditDefaultSwap::PricingModel arg18 ;
  UpfrontCdsHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = (Date *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg16 = (DayCounter *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg17 = jarg17 ? true : false; 
  arg18 = (CreditDefaultSwap::PricingModel)jarg18; 
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper((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,(Date const &)*arg15,(DayCounter const &)*arg16,arg17,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 = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, unsigned int jarg14, void * jarg15, void * jarg16, unsigned int jarg17) {
  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 ;
  Date *arg15 = 0 ;
  DayCounter *arg16 = 0 ;
  bool arg17 ;
  UpfrontCdsHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = (Date *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg16 = (DayCounter *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper((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,(Date const &)*arg15,(DayCounter const &)*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 = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, unsigned int jarg13, unsigned int jarg14, void * jarg15, void * jarg16) {
  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 ;
  Date *arg15 = 0 ;
  DayCounter *arg16 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = (Date *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg16 = (DayCounter *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper((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,(Date const &)*arg15,(DayCounter 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 = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, unsigned int jarg12, unsigned int jarg13, unsigned int jarg14, void * jarg15) {
  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 ;
  Date *arg15 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = (Date *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper((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,(Date 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 = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_4(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 ;
  UpfrontCdsHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper((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 = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_5(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 ;
  UpfrontCdsHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper((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 = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_6(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 ;
  UpfrontCdsHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper((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 = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_7(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 ;
  UpfrontCdsHelper *result = 0 ;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper((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 = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_8(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 * jarg15, void * jarg16, unsigned int jarg17, int jarg18) {
  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 ;
  Date *arg15 = 0 ;
  DayCounter *arg16 = 0 ;
  bool arg17 ;
  CreditDefaultSwap::PricingModel arg18 ;
  UpfrontCdsHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = (Date *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg16 = (DayCounter *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg17 = jarg17 ? true : false; 
  arg18 = (CreditDefaultSwap::PricingModel)jarg18; 
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper(arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13,arg14,(Date const &)*arg15,(DayCounter const &)*arg16,arg17,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 = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_9(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 * jarg15, void * jarg16, unsigned int jarg17) {
  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 ;
  Date *arg15 = 0 ;
  DayCounter *arg16 = 0 ;
  bool arg17 ;
  UpfrontCdsHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = (Date *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg16 = (DayCounter *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg17 = jarg17 ? true : false; 
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper(arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13,arg14,(Date const &)*arg15,(DayCounter const &)*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 = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_10(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 * jarg15, void * jarg16) {
  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 ;
  Date *arg15 = 0 ;
  DayCounter *arg16 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = (Date *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg16 = (DayCounter *)jarg16;
  if (!arg16) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper(arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13,arg14,(Date const &)*arg15,(DayCounter 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 = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_11(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 * jarg15) {
  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 ;
  Date *arg15 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  arg15 = (Date *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper(arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13,arg14,(Date 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 = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_12(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 ;
  UpfrontCdsHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  arg13 = jarg13 ? true : false; 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper(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 = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_13(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 ;
  UpfrontCdsHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper(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 = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_14(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 ;
  UpfrontCdsHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg12 = (Natural)jarg12; 
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper(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 = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_UpfrontCdsHelper__SWIG_15(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 ;
  UpfrontCdsHelper *result = 0 ;
  
  arg1 = (Rate)jarg1; 
  arg2 = (Rate)jarg2; 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Integer)jarg4; 
  arg5 = (Calendar *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & 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 & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Handle< YieldTermStructure > *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper(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 = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_UpfrontCdsHelper(void * jarg1) {
  UpfrontCdsHelper *arg1 = (UpfrontCdsHelper *) 0 ;
  ext::shared_ptr< UpfrontCdsHelper > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  UpfrontCdsHelper > *)jarg1;
  arg1 = (UpfrontCdsHelper *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  BackwardFlat *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  PiecewiseFlatHazardRate *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (BackwardFlat *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const &)*arg2,(DayCounter const &)*arg3,(BackwardFlat const &)*arg4,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseFlatHazardRate >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatHazardRate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  BackwardFlat *arg4 = 0 ;
  PiecewiseFlatHazardRate *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (BackwardFlat *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const &)*arg2,(DayCounter const &)*arg3,(BackwardFlat 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 ? new ext::shared_ptr<  PiecewiseFlatHazardRate >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatHazardRate__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  PiecewiseFlatHazardRate *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_0((Date const &)*arg1,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseFlatHazardRate >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatHazardRate__SWIG_3(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BackwardFlat *arg5 = 0 ;
  _IterativeBootstrap *arg6 = 0 ;
  PiecewiseFlatHazardRate *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BackwardFlat *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & is null", 0);
    return 0;
  } 
  arg6 = (_IterativeBootstrap *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_3(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const &)*arg3,(DayCounter const &)*arg4,(BackwardFlat const &)*arg5,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseFlatHazardRate >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatHazardRate__SWIG_4(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BackwardFlat *arg5 = 0 ;
  PiecewiseFlatHazardRate *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (BackwardFlat *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_3(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const &)*arg3,(DayCounter 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 = result ? new ext::shared_ptr<  PiecewiseFlatHazardRate >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< DefaultProbabilityHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  PiecewiseFlatHazardRate *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_3(arg1,(Calendar const &)*arg2,(std::vector< ext::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 = result ? new ext::shared_ptr<  PiecewiseFlatHazardRate >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatHazardRate__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  PiecewiseFlatHazardRate *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (_IterativeBootstrap *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_6((Date const &)*arg1,(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseFlatHazardRate >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_PiecewiseFlatHazardRate__SWIG_7(int jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  PiecewiseFlatHazardRate *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (_IterativeBootstrap *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "_IterativeBootstrap const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_7(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap 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 ? new ext::shared_ptr<  PiecewiseFlatHazardRate >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseFlatHazardRate_dates(void * jarg1) {
  void * jresult ;
  PiecewiseFlatHazardRate *arg1 = (PiecewiseFlatHazardRate *) 0 ;
  ext::shared_ptr< PiecewiseFlatHazardRate const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseFlatHazardRate > *)jarg1;
  arg1 = (PiecewiseFlatHazardRate *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((PiecewiseFlatHazardRate 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_PiecewiseFlatHazardRate_times(void * jarg1) {
  void * jresult ;
  PiecewiseFlatHazardRate *arg1 = (PiecewiseFlatHazardRate *) 0 ;
  ext::shared_ptr< PiecewiseFlatHazardRate const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseFlatHazardRate > *)jarg1;
  arg1 = (PiecewiseFlatHazardRate *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseFlatHazardRate 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseFlatHazardRate_nodes(void * jarg1) {
  void * jresult ;
  PiecewiseFlatHazardRate *arg1 = (PiecewiseFlatHazardRate *) 0 ;
  ext::shared_ptr< PiecewiseFlatHazardRate const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Real > > result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseFlatHazardRate > *)jarg1;
  arg1 = (PiecewiseFlatHazardRate *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseFlatHazardRate const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_PiecewiseFlatHazardRate(void * jarg1) {
  PiecewiseFlatHazardRate *arg1 = (PiecewiseFlatHazardRate *) 0 ;
  ext::shared_ptr< PiecewiseFlatHazardRate > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseFlatHazardRate > *)jarg1;
  arg1 = (PiecewiseFlatHazardRate *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RiskyBondEngine(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  RiskyBondEngine *result = 0 ;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (RiskyBondEngine *)new RiskyBondEngine((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 = result ? new ext::shared_ptr<  RiskyBondEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RiskyBondEngine(void * jarg1) {
  RiskyBondEngine *arg1 = (RiskyBondEngine *) 0 ;
  ext::shared_ptr< RiskyBondEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  RiskyBondEngine > *)jarg1;
  arg1 = (RiskyBondEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 double SWIGSTDCALL CSharp_QuantLib_Claim_amount(void * jarg1, void * jarg2, double jarg3, double jarg4) {
  double jresult ;
  Claim *arg1 = (Claim *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  ext::shared_ptr< Claim const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Claim > *)jarg1;
  arg1 = (Claim *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)((Claim const *)arg1)->amount((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 void SWIGSTDCALL CSharp_QuantLib_delete_Claim(void * jarg1) {
  Claim *arg1 = (Claim *) 0 ;
  ext::shared_ptr< Claim > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Claim > *)jarg1;
  arg1 = (Claim *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FaceValueClaim(void * jarg1) {
  FaceValueClaim *arg1 = (FaceValueClaim *) 0 ;
  ext::shared_ptr< FaceValueClaim > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FaceValueClaim > *)jarg1;
  arg1 = (FaceValueClaim *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FaceValueAccrualClaim(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< Bond > *arg1 = 0 ;
  ext::shared_ptr< Bond > tempnull1 ;
  FaceValueAccrualClaim *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Bond > *)jarg1 : &tempnull1; 
  {
    try {
      result = (FaceValueAccrualClaim *)new FaceValueAccrualClaim((ext::shared_ptr< Bond > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FaceValueAccrualClaim >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FaceValueAccrualClaim(void * jarg1) {
  FaceValueAccrualClaim *arg1 = (FaceValueAccrualClaim *) 0 ;
  ext::shared_ptr< FaceValueAccrualClaim > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FaceValueAccrualClaim > *)jarg1;
  arg1 = (FaceValueAccrualClaim *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, void * jarg13, unsigned int jarg14) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  Date *arg9 = 0 ;
  ext::shared_ptr< Claim > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  Date *arg13 = 0 ;
  Natural arg14 ;
  ext::shared_ptr< Claim > tempnull10 ;
  CreditDefaultSwap *result = 0 ;
  
  arg1 = (Protection::Side)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = jarg8 ? true : false; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? (ext::shared_ptr< Claim > *)jarg10 : &tempnull10; 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg14 = (Natural)jarg14; 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(ext::shared_ptr< Claim > const &)*arg10,(DayCounter const &)*arg11,arg12,(Date 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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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, unsigned int jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12, void * jarg13) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  Date *arg9 = 0 ;
  ext::shared_ptr< Claim > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  Date *arg13 = 0 ;
  ext::shared_ptr< Claim > tempnull10 ;
  CreditDefaultSwap *result = 0 ;
  
  arg1 = (Protection::Side)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = jarg8 ? true : false; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? (ext::shared_ptr< Claim > *)jarg10 : &tempnull10; 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  arg13 = (Date *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(ext::shared_ptr< Claim > const &)*arg10,(DayCounter const &)*arg11,arg12,(Date 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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_2(int jarg1, double jarg2, double jarg3, void * jarg4, int jarg5, void * jarg6, unsigned int jarg7, unsigned int jarg8, void * jarg9, void * jarg10, void * jarg11, unsigned int jarg12) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  Date *arg9 = 0 ;
  ext::shared_ptr< Claim > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  ext::shared_ptr< Claim > tempnull10 ;
  CreditDefaultSwap *result = 0 ;
  
  arg1 = (Protection::Side)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = jarg8 ? true : false; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? (ext::shared_ptr< Claim > *)jarg10 : &tempnull10; 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(ext::shared_ptr< Claim > 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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_3(int jarg1, double jarg2, double jarg3, void * jarg4, int jarg5, void * jarg6, unsigned int jarg7, unsigned int jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  Date *arg9 = 0 ;
  ext::shared_ptr< Claim > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  ext::shared_ptr< Claim > tempnull10 ;
  CreditDefaultSwap *result = 0 ;
  
  arg1 = (Protection::Side)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = jarg8 ? true : false; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? (ext::shared_ptr< Claim > *)jarg10 : &tempnull10; 
  arg11 = (DayCounter *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(ext::shared_ptr< Claim > 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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_4(int jarg1, double jarg2, double jarg3, void * jarg4, int jarg5, void * jarg6, unsigned int jarg7, unsigned int jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  Date *arg9 = 0 ;
  ext::shared_ptr< Claim > *arg10 = 0 ;
  ext::shared_ptr< Claim > tempnull10 ;
  CreditDefaultSwap *result = 0 ;
  
  arg1 = (Protection::Side)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = jarg8 ? true : false; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg10 = jarg10 ? (ext::shared_ptr< Claim > *)jarg10 : &tempnull10; 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(ext::shared_ptr< Claim > 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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_5(int jarg1, double jarg2, double jarg3, void * jarg4, int jarg5, void * jarg6, unsigned int jarg7, unsigned int jarg8, void * jarg9) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  Date *arg9 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  arg1 = (Protection::Side)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = jarg8 ? true : false; 
  arg9 = (Date *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,(Schedule const &)*arg4,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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_6(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 ;
  CreditDefaultSwap *result = 0 ;
  
  arg1 = (Protection::Side)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_7(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 ;
  CreditDefaultSwap *result = 0 ;
  
  arg1 = (Protection::Side)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? true : false; 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_8(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 ;
  CreditDefaultSwap *result = 0 ;
  
  arg1 = (Protection::Side)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Schedule *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Schedule const & is null", 0);
    return 0;
  } 
  arg5 = (BusinessDayConvention)jarg5; 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_9(int jarg1, double jarg2, double jarg3, double jarg4, void * jarg5, int jarg6, void * jarg7, unsigned int jarg8, unsigned int jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13, unsigned int jarg14, void * jarg15, unsigned int jarg16) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  bool arg9 ;
  Date *arg10 = 0 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< Claim > *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  Natural arg16 ;
  ext::shared_ptr< Claim > tempnull12 ;
  CreditDefaultSwap *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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = jarg9 ? true : false; 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? (ext::shared_ptr< Claim > *)jarg12 : &tempnull12; 
  arg13 = (DayCounter *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg14 = jarg14 ? true : false; 
  arg15 = (Date *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg16 = (Natural)jarg16; 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,arg9,(Date const &)*arg10,(Date const &)*arg11,(ext::shared_ptr< Claim > const &)*arg12,(DayCounter const &)*arg13,arg14,(Date 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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_10(int jarg1, double jarg2, double jarg3, double jarg4, void * jarg5, int jarg6, void * jarg7, unsigned int jarg8, unsigned int jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13, unsigned int jarg14, void * jarg15) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  bool arg9 ;
  Date *arg10 = 0 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< Claim > *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  ext::shared_ptr< Claim > tempnull12 ;
  CreditDefaultSwap *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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = jarg9 ? true : false; 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? (ext::shared_ptr< Claim > *)jarg12 : &tempnull12; 
  arg13 = (DayCounter *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg14 = jarg14 ? true : false; 
  arg15 = (Date *)jarg15;
  if (!arg15) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,arg9,(Date const &)*arg10,(Date const &)*arg11,(ext::shared_ptr< Claim > const &)*arg12,(DayCounter const &)*arg13,arg14,(Date 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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_11(int jarg1, double jarg2, double jarg3, double jarg4, void * jarg5, int jarg6, void * jarg7, unsigned int jarg8, unsigned int jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13, unsigned int jarg14) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  bool arg9 ;
  Date *arg10 = 0 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< Claim > *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  ext::shared_ptr< Claim > tempnull12 ;
  CreditDefaultSwap *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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = jarg9 ? true : false; 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? (ext::shared_ptr< Claim > *)jarg12 : &tempnull12; 
  arg13 = (DayCounter *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg14 = jarg14 ? true : false; 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,arg9,(Date const &)*arg10,(Date const &)*arg11,(ext::shared_ptr< Claim > 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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_12(int jarg1, double jarg2, double jarg3, double jarg4, void * jarg5, int jarg6, void * jarg7, unsigned int jarg8, unsigned int jarg9, void * jarg10, void * jarg11, void * jarg12, void * jarg13) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  bool arg9 ;
  Date *arg10 = 0 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< Claim > *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  ext::shared_ptr< Claim > tempnull12 ;
  CreditDefaultSwap *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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = jarg9 ? true : false; 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? (ext::shared_ptr< Claim > *)jarg12 : &tempnull12; 
  arg13 = (DayCounter *)jarg13;
  if (!arg13) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,arg9,(Date const &)*arg10,(Date const &)*arg11,(ext::shared_ptr< Claim > 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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_13(int jarg1, double jarg2, double jarg3, double jarg4, void * jarg5, int jarg6, void * jarg7, unsigned int jarg8, unsigned int jarg9, void * jarg10, void * jarg11, void * jarg12) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  bool arg9 ;
  Date *arg10 = 0 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< Claim > *arg12 = 0 ;
  ext::shared_ptr< Claim > tempnull12 ;
  CreditDefaultSwap *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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = jarg9 ? true : false; 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg12 = jarg12 ? (ext::shared_ptr< Claim > *)jarg12 : &tempnull12; 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,arg9,(Date const &)*arg10,(Date const &)*arg11,(ext::shared_ptr< Claim > 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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_14(int jarg1, double jarg2, double jarg3, double jarg4, void * jarg5, int jarg6, void * jarg7, unsigned int jarg8, unsigned int jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  bool arg9 ;
  Date *arg10 = 0 ;
  Date *arg11 = 0 ;
  CreditDefaultSwap *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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = jarg9 ? true : false; 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg11 = (Date *)jarg11;
  if (!arg11) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,arg9,(Date const &)*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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_15(int jarg1, double jarg2, double jarg3, double jarg4, void * jarg5, int jarg6, void * jarg7, unsigned int jarg8, unsigned int jarg9, void * jarg10) {
  void * jresult ;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  bool arg9 ;
  Date *arg10 = 0 ;
  CreditDefaultSwap *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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = jarg9 ? true : false; 
  arg10 = (Date *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_16(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 ;
  CreditDefaultSwap *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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = jarg9 ? true : false; 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_17(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 ;
  CreditDefaultSwap *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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CreditDefaultSwap__SWIG_18(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 ;
  CreditDefaultSwap *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 & is null", 0);
    return 0;
  } 
  arg6 = (BusinessDayConvention)jarg6; 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(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 = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_side(void * jarg1) {
  int jresult ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Protection::Side result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Protection::Side)((CreditDefaultSwap const *)arg1)->side();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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 ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((CreditDefaultSwap const *)arg1)->notional();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->runningSpread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  doubleOrNull result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (doubleOrNull)CreditDefaultSwap_upfront((CreditDefaultSwap const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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 ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((CreditDefaultSwap const *)arg1)->settlesAccrual();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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 ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((CreditDefaultSwap const *)arg1)->paysAtDefaultTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap > *smartarg1 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > > result;
  
  
  smartarg1 = (ext::shared_ptr<  CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->coupons();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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< ext::shared_ptr< CashFlow > >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_protectionStartDate(void * jarg1) {
  void * jresult ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Date *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Date *) &((CreditDefaultSwap const *)arg1)->protectionStartDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_protectionEndDate(void * jarg1) {
  void * jresult ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Date *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Date *) &((CreditDefaultSwap const *)arg1)->protectionEndDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_CreditDefaultSwap_rebatesAccrual(void * jarg1) {
  unsigned int jresult ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (bool)((CreditDefaultSwap const *)arg1)->rebatesAccrual();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_upfrontPayment(void * jarg1) {
  void * jresult ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  ext::shared_ptr< CashFlow > result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((CreditDefaultSwap const *)arg1)->upfrontPayment();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< CashFlow >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_accrualRebate(void * jarg1) {
  void * jresult ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  ext::shared_ptr< CashFlow > result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((CreditDefaultSwap const *)arg1)->accrualRebate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< CashFlow >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_tradeDate(void * jarg1) {
  void * jresult ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Date *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Date *) &((CreditDefaultSwap const *)arg1)->tradeDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_CreditDefaultSwap_cashSettlementDays(void * jarg1) {
  unsigned int jresult ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Natural result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Natural)((CreditDefaultSwap const *)arg1)->cashSettlementDays();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->fairUpfront();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->fairSpread();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((CreditDefaultSwap const *)arg1)->couponLegBPS();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((CreditDefaultSwap const *)arg1)->upfrontBPS();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((CreditDefaultSwap const *)arg1)->couponLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((CreditDefaultSwap const *)arg1)->defaultLegNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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 ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((CreditDefaultSwap const *)arg1)->upfrontNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_accrualRebateNPV(void * jarg1) {
  double jresult ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((CreditDefaultSwap const *)arg1)->accrualRebateNPV();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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, int jarg7) {
  double jresult ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  CreditDefaultSwap::PricingModel arg7 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (CreditDefaultSwap::PricingModel)jarg7; 
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->impliedHazardRate(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_CreditDefaultSwap_impliedHazardRate__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6) {
  double jresult ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->impliedHazardRate(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_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5) {
  double jresult ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Real arg5 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->impliedHazardRate(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_3(void * jarg1, double jarg2, void * jarg3, void * jarg4) {
  double jresult ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->impliedHazardRate(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 double SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_conventionalSpread__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, int jarg5) {
  double jresult ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  CreditDefaultSwap::PricingModel arg5 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (CreditDefaultSwap::PricingModel)jarg5; 
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->conventionalSpread(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_conventionalSpread__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4) {
  double jresult ;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->conventionalSpread(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_delete_CreditDefaultSwap(void * jarg1) {
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  ext::shared_ptr< CreditDefaultSwap > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CreditDefaultSwap > *)jarg1;
  arg1 = (CreditDefaultSwap *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  MidPointCdsEngine *result = 0 ;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MidPointCdsEngine *)new MidPointCdsEngine((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 = result ? new ext::shared_ptr<  MidPointCdsEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MidPointCdsEngine(void * jarg1) {
  MidPointCdsEngine *arg1 = (MidPointCdsEngine *) 0 ;
  ext::shared_ptr< MidPointCdsEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MidPointCdsEngine > *)jarg1;
  arg1 = (MidPointCdsEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  IntegralCdsEngine *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< DefaultProbabilityTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (IntegralCdsEngine *)new IntegralCdsEngine((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 = result ? new ext::shared_ptr<  IntegralCdsEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  IntegralCdsEngine *result = 0 ;
  
  arg1 = (Period *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< DefaultProbabilityTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (IntegralCdsEngine *)new IntegralCdsEngine((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 = result ? new ext::shared_ptr<  IntegralCdsEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IntegralCdsEngine(void * jarg1) {
  IntegralCdsEngine *arg1 = (IntegralCdsEngine *) 0 ;
  ext::shared_ptr< IntegralCdsEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  IntegralCdsEngine > *)jarg1;
  arg1 = (IntegralCdsEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IsdaCdsEngine__SWIG_0(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, int jarg5, int jarg6, int jarg7) {
  void * jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  bool arg4 ;
  IsdaCdsEngine::NumericalFix arg5 ;
  IsdaCdsEngine::AccrualBias arg6 ;
  IsdaCdsEngine::ForwardsInCouponPeriod arg7 ;
  IsdaCdsEngine *result = 0 ;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (IsdaCdsEngine::NumericalFix)jarg5; 
  arg6 = (IsdaCdsEngine::AccrualBias)jarg6; 
  arg7 = (IsdaCdsEngine::ForwardsInCouponPeriod)jarg7; 
  {
    try {
      result = (IsdaCdsEngine *)new IsdaCdsEngine((Handle< DefaultProbabilityTermStructure > 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 ? new ext::shared_ptr<  IsdaCdsEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IsdaCdsEngine__SWIG_1(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, int jarg5, int jarg6) {
  void * jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  bool arg4 ;
  IsdaCdsEngine::NumericalFix arg5 ;
  IsdaCdsEngine::AccrualBias arg6 ;
  IsdaCdsEngine *result = 0 ;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (IsdaCdsEngine::NumericalFix)jarg5; 
  arg6 = (IsdaCdsEngine::AccrualBias)jarg6; 
  {
    try {
      result = (IsdaCdsEngine *)new IsdaCdsEngine((Handle< DefaultProbabilityTermStructure > 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 ? new ext::shared_ptr<  IsdaCdsEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IsdaCdsEngine__SWIG_2(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4, int jarg5) {
  void * jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  bool arg4 ;
  IsdaCdsEngine::NumericalFix arg5 ;
  IsdaCdsEngine *result = 0 ;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  arg5 = (IsdaCdsEngine::NumericalFix)jarg5; 
  {
    try {
      result = (IsdaCdsEngine *)new IsdaCdsEngine((Handle< DefaultProbabilityTermStructure > 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 ? new ext::shared_ptr<  IsdaCdsEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IsdaCdsEngine__SWIG_3(void * jarg1, double jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  bool arg4 ;
  IsdaCdsEngine *result = 0 ;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (IsdaCdsEngine *)new IsdaCdsEngine((Handle< DefaultProbabilityTermStructure > 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 ? new ext::shared_ptr<  IsdaCdsEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_IsdaCdsEngine__SWIG_4(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  IsdaCdsEngine *result = 0 ;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (IsdaCdsEngine *)new IsdaCdsEngine((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 = result ? new ext::shared_ptr<  IsdaCdsEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_IsdaCdsEngine(void * jarg1) {
  IsdaCdsEngine *arg1 = (IsdaCdsEngine *) 0 ;
  ext::shared_ptr< IsdaCdsEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  IsdaCdsEngine > *)jarg1;
  arg1 = (IsdaCdsEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CdsOption__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  void * jresult ;
  ext::shared_ptr< CreditDefaultSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  bool arg3 ;
  ext::shared_ptr< CreditDefaultSwap > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  CdsOption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CreditDefaultSwap > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (CdsOption *)new CdsOption((ext::shared_ptr< CreditDefaultSwap > const &)*arg1,(ext::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 = result ? new ext::shared_ptr<  CdsOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CdsOption__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< CreditDefaultSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  ext::shared_ptr< CreditDefaultSwap > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  CdsOption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CreditDefaultSwap > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  {
    try {
      result = (CdsOption *)new CdsOption((ext::shared_ptr< CreditDefaultSwap > const &)*arg1,(ext::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 = result ? new ext::shared_ptr<  CdsOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CdsOption_atmRate(void * jarg1) {
  double jresult ;
  CdsOption *arg1 = (CdsOption *) 0 ;
  ext::shared_ptr< CdsOption const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const CdsOption > *)jarg1;
  arg1 = (CdsOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((CdsOption const *)arg1)->atmRate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CdsOption_riskyAnnuity(void * jarg1) {
  double jresult ;
  CdsOption *arg1 = (CdsOption *) 0 ;
  ext::shared_ptr< CdsOption const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const CdsOption > *)jarg1;
  arg1 = (CdsOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((CdsOption const *)arg1)->riskyAnnuity();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CdsOption_impliedVolatility__SWIG_0(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6, unsigned long jarg7, double jarg8, double jarg9) {
  double jresult ;
  CdsOption *arg1 = (CdsOption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< DefaultProbabilityTermStructure > *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  Volatility arg8 ;
  Volatility arg9 ;
  ext::shared_ptr< CdsOption const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const CdsOption > *)jarg1;
  arg1 = (CdsOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< DefaultProbabilityTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Volatility)jarg8; 
  arg9 = (Volatility)jarg9; 
  {
    try {
      result = (Volatility)((CdsOption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< DefaultProbabilityTermStructure > 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_CdsOption_impliedVolatility__SWIG_1(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6, unsigned long jarg7, double jarg8) {
  double jresult ;
  CdsOption *arg1 = (CdsOption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< DefaultProbabilityTermStructure > *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  Volatility arg8 ;
  ext::shared_ptr< CdsOption const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const CdsOption > *)jarg1;
  arg1 = (CdsOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< DefaultProbabilityTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Volatility)jarg8; 
  {
    try {
      result = (Volatility)((CdsOption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< DefaultProbabilityTermStructure > 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_CdsOption_impliedVolatility__SWIG_2(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6, unsigned long jarg7) {
  double jresult ;
  CdsOption *arg1 = (CdsOption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< DefaultProbabilityTermStructure > *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  ext::shared_ptr< CdsOption const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const CdsOption > *)jarg1;
  arg1 = (CdsOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< DefaultProbabilityTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (Volatility)((CdsOption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< DefaultProbabilityTermStructure > 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_CdsOption_impliedVolatility__SWIG_3(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5, double jarg6) {
  double jresult ;
  CdsOption *arg1 = (CdsOption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< DefaultProbabilityTermStructure > *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  ext::shared_ptr< CdsOption const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const CdsOption > *)jarg1;
  arg1 = (CdsOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< DefaultProbabilityTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (Volatility)((CdsOption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< DefaultProbabilityTermStructure > 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_CdsOption_impliedVolatility__SWIG_4(void * jarg1, double jarg2, void * jarg3, void * jarg4, double jarg5) {
  double jresult ;
  CdsOption *arg1 = (CdsOption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< DefaultProbabilityTermStructure > *arg4 = 0 ;
  Real arg5 ;
  ext::shared_ptr< CdsOption const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const CdsOption > *)jarg1;
  arg1 = (CdsOption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< DefaultProbabilityTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Volatility)((CdsOption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< DefaultProbabilityTermStructure > 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 void SWIGSTDCALL CSharp_QuantLib_delete_CdsOption(void * jarg1) {
  CdsOption *arg1 = (CdsOption *) 0 ;
  ext::shared_ptr< CdsOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CdsOption > *)jarg1;
  arg1 = (CdsOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BlackCdsOptionEngine(void * jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Handle< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  BlackCdsOptionEngine *result = 0 ;
  
  arg1 = (Handle< DefaultProbabilityTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< DefaultProbabilityTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackCdsOptionEngine *)new BlackCdsOptionEngine((Handle< DefaultProbabilityTermStructure > const &)*arg1,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 = result ? new ext::shared_ptr<  BlackCdsOptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackCdsOptionEngine_termStructure(void * jarg1) {
  void * jresult ;
  BlackCdsOptionEngine *arg1 = (BlackCdsOptionEngine *) 0 ;
  ext::shared_ptr< BlackCdsOptionEngine > *smartarg1 = 0 ;
  Handle< YieldTermStructure > result;
  
  
  smartarg1 = (ext::shared_ptr<  BlackCdsOptionEngine > *)jarg1;
  arg1 = (BlackCdsOptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (arg1)->termStructure();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BlackCdsOptionEngine_volatility(void * jarg1) {
  void * jresult ;
  BlackCdsOptionEngine *arg1 = (BlackCdsOptionEngine *) 0 ;
  ext::shared_ptr< BlackCdsOptionEngine > *smartarg1 = 0 ;
  Handle< Quote > result;
  
  
  smartarg1 = (ext::shared_ptr<  BlackCdsOptionEngine > *)jarg1;
  arg1 = (BlackCdsOptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackCdsOptionEngine(void * jarg1) {
  BlackCdsOptionEngine *arg1 = (BlackCdsOptionEngine *) 0 ;
  ext::shared_ptr< BlackCdsOptionEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackCdsOptionEngine > *)jarg1;
  arg1 = (BlackCdsOptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  InterpolatedDiscountCurve< LogLinear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (LogLinear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogLinear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< LogLinear > *)new InterpolatedDiscountCurve< LogLinear >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > 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 = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<LogLinear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedDiscountCurve< LogLinear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< LogLinear > *)new InterpolatedDiscountCurve< LogLinear >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > 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 = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<LogLinear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedDiscountCurve< LogLinear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< LogLinear > *)new InterpolatedDiscountCurve< LogLinear >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > 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 = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<LogLinear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DiscountCurve_times(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< LogLinear > *arg1 = (InterpolatedDiscountCurve< LogLinear > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<LogLinear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((InterpolatedDiscountCurve< LogLinear > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_DiscountCurve_data(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< LogLinear > *arg1 = (InterpolatedDiscountCurve< LogLinear > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<LogLinear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedDiscountCurve< LogLinear > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  InterpolatedDiscountCurve< LogLinear > *arg1 = (InterpolatedDiscountCurve< LogLinear > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<LogLinear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedDiscountCurve< LogLinear > 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_DiscountCurve_discounts(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< LogLinear > *arg1 = (InterpolatedDiscountCurve< LogLinear > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > const > *smartarg1 = 0 ;
  std::vector< DiscountFactor > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<LogLinear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< DiscountFactor > *) &((InterpolatedDiscountCurve< LogLinear > const *)arg1)->discounts();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  InterpolatedDiscountCurve< LogLinear > *arg1 = (InterpolatedDiscountCurve< LogLinear > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,DiscountFactor > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<LogLinear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedDiscountCurve< LogLinear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DiscountCurve(void * jarg1) {
  InterpolatedDiscountCurve< LogLinear > *arg1 = (InterpolatedDiscountCurve< LogLinear > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedDiscountCurve<LogLinear> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<LogLinear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicLogCubicDiscountCurve__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 ;
  MonotonicLogCubic *arg5 = 0 ;
  InterpolatedDiscountCurve< MonotonicLogCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (MonotonicLogCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicLogCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< MonotonicLogCubic > *)new InterpolatedDiscountCurve< MonotonicLogCubic >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(MonotonicLogCubic 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 ? new ext::shared_ptr<  InterpolatedDiscountCurve<MonotonicLogCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicLogCubicDiscountCurve__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 ;
  InterpolatedDiscountCurve< MonotonicLogCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< MonotonicLogCubic > *)new InterpolatedDiscountCurve< MonotonicLogCubic >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > 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 = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<MonotonicLogCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MonotonicLogCubicDiscountCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< DiscountFactor > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  InterpolatedDiscountCurve< MonotonicLogCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< MonotonicLogCubic > *)new InterpolatedDiscountCurve< MonotonicLogCubic >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > 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 = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<MonotonicLogCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MonotonicLogCubicDiscountCurve_times(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< MonotonicLogCubic > *arg1 = (InterpolatedDiscountCurve< MonotonicLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<MonotonicLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((InterpolatedDiscountCurve< MonotonicLogCubic > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MonotonicLogCubicDiscountCurve_data(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< MonotonicLogCubic > *arg1 = (InterpolatedDiscountCurve< MonotonicLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<MonotonicLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedDiscountCurve< MonotonicLogCubic > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MonotonicLogCubicDiscountCurve_dates(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< MonotonicLogCubic > *arg1 = (InterpolatedDiscountCurve< MonotonicLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<MonotonicLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedDiscountCurve< MonotonicLogCubic > 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_MonotonicLogCubicDiscountCurve_discounts(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< MonotonicLogCubic > *arg1 = (InterpolatedDiscountCurve< MonotonicLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > const > *smartarg1 = 0 ;
  std::vector< DiscountFactor > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<MonotonicLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< DiscountFactor > *) &((InterpolatedDiscountCurve< MonotonicLogCubic > const *)arg1)->discounts();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MonotonicLogCubicDiscountCurve_nodes(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< MonotonicLogCubic > *arg1 = (InterpolatedDiscountCurve< MonotonicLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,DiscountFactor > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<MonotonicLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedDiscountCurve< MonotonicLogCubic > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MonotonicLogCubicDiscountCurve(void * jarg1) {
  InterpolatedDiscountCurve< MonotonicLogCubic > *arg1 = (InterpolatedDiscountCurve< MonotonicLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedDiscountCurve<MonotonicLogCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<MonotonicLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NaturalCubicDiscountCurve__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 ;
  SplineCubic *arg5 = 0 ;
  InterpolatedDiscountCurve< SplineCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (SplineCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< SplineCubic > *)new InterpolatedDiscountCurve< SplineCubic >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(SplineCubic 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 ? new ext::shared_ptr<  InterpolatedDiscountCurve<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NaturalCubicDiscountCurve__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 ;
  InterpolatedDiscountCurve< SplineCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< SplineCubic > *)new InterpolatedDiscountCurve< SplineCubic >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > 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 = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NaturalCubicDiscountCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< DiscountFactor > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  InterpolatedDiscountCurve< SplineCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< SplineCubic > *)new InterpolatedDiscountCurve< SplineCubic >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > 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 = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NaturalCubicDiscountCurve_times(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< SplineCubic > *arg1 = (InterpolatedDiscountCurve< SplineCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<SplineCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((InterpolatedDiscountCurve< SplineCubic > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NaturalCubicDiscountCurve_data(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< SplineCubic > *arg1 = (InterpolatedDiscountCurve< SplineCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<SplineCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedDiscountCurve< SplineCubic > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NaturalCubicDiscountCurve_dates(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< SplineCubic > *arg1 = (InterpolatedDiscountCurve< SplineCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<SplineCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedDiscountCurve< SplineCubic > 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_NaturalCubicDiscountCurve_discounts(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< SplineCubic > *arg1 = (InterpolatedDiscountCurve< SplineCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > const > *smartarg1 = 0 ;
  std::vector< DiscountFactor > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<SplineCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< DiscountFactor > *) &((InterpolatedDiscountCurve< SplineCubic > const *)arg1)->discounts();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NaturalCubicDiscountCurve_nodes(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< SplineCubic > *arg1 = (InterpolatedDiscountCurve< SplineCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,DiscountFactor > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<SplineCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedDiscountCurve< SplineCubic > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NaturalCubicDiscountCurve(void * jarg1) {
  InterpolatedDiscountCurve< SplineCubic > *arg1 = (InterpolatedDiscountCurve< SplineCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedDiscountCurve<SplineCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<SplineCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KrugerLogDiscountCurve__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 ;
  KrugerLog *arg5 = 0 ;
  InterpolatedDiscountCurve< KrugerLog > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (KrugerLog *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KrugerLog const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< KrugerLog > *)new InterpolatedDiscountCurve< KrugerLog >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(KrugerLog 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 ? new ext::shared_ptr<  InterpolatedDiscountCurve<KrugerLog> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KrugerLogDiscountCurve__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 ;
  InterpolatedDiscountCurve< KrugerLog > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< KrugerLog > *)new InterpolatedDiscountCurve< KrugerLog >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > 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 = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<KrugerLog> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KrugerLogDiscountCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< DiscountFactor > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  InterpolatedDiscountCurve< KrugerLog > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< KrugerLog > *)new InterpolatedDiscountCurve< KrugerLog >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > 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 = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<KrugerLog> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_KrugerLogDiscountCurve_times(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< KrugerLog > *arg1 = (InterpolatedDiscountCurve< KrugerLog > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<KrugerLog> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((InterpolatedDiscountCurve< KrugerLog > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_KrugerLogDiscountCurve_data(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< KrugerLog > *arg1 = (InterpolatedDiscountCurve< KrugerLog > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<KrugerLog> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedDiscountCurve< KrugerLog > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_KrugerLogDiscountCurve_dates(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< KrugerLog > *arg1 = (InterpolatedDiscountCurve< KrugerLog > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<KrugerLog> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedDiscountCurve< KrugerLog > 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_KrugerLogDiscountCurve_discounts(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< KrugerLog > *arg1 = (InterpolatedDiscountCurve< KrugerLog > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > const > *smartarg1 = 0 ;
  std::vector< DiscountFactor > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<KrugerLog> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< DiscountFactor > *) &((InterpolatedDiscountCurve< KrugerLog > const *)arg1)->discounts();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_KrugerLogDiscountCurve_nodes(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< KrugerLog > *arg1 = (InterpolatedDiscountCurve< KrugerLog > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,DiscountFactor > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<KrugerLog> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedDiscountCurve< KrugerLog > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_KrugerLogDiscountCurve(void * jarg1) {
  InterpolatedDiscountCurve< KrugerLog > *arg1 = (InterpolatedDiscountCurve< KrugerLog > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedDiscountCurve<KrugerLog> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<KrugerLog> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NaturalLogCubicDiscountCurve__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 ;
  SplineLogCubic *arg5 = 0 ;
  InterpolatedDiscountCurve< SplineLogCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (SplineLogCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineLogCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< SplineLogCubic > *)new InterpolatedDiscountCurve< SplineLogCubic >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(SplineLogCubic 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 ? new ext::shared_ptr<  InterpolatedDiscountCurve<SplineLogCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NaturalLogCubicDiscountCurve__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 ;
  InterpolatedDiscountCurve< SplineLogCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< SplineLogCubic > *)new InterpolatedDiscountCurve< SplineLogCubic >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > 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 = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<SplineLogCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NaturalLogCubicDiscountCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< DiscountFactor > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  InterpolatedDiscountCurve< SplineLogCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< SplineLogCubic > *)new InterpolatedDiscountCurve< SplineLogCubic >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > 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 = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<SplineLogCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NaturalLogCubicDiscountCurve_times(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< SplineLogCubic > *arg1 = (InterpolatedDiscountCurve< SplineLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<SplineLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((InterpolatedDiscountCurve< SplineLogCubic > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NaturalLogCubicDiscountCurve_data(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< SplineLogCubic > *arg1 = (InterpolatedDiscountCurve< SplineLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<SplineLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedDiscountCurve< SplineLogCubic > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NaturalLogCubicDiscountCurve_dates(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< SplineLogCubic > *arg1 = (InterpolatedDiscountCurve< SplineLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<SplineLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedDiscountCurve< SplineLogCubic > 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_NaturalLogCubicDiscountCurve_discounts(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< SplineLogCubic > *arg1 = (InterpolatedDiscountCurve< SplineLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > const > *smartarg1 = 0 ;
  std::vector< DiscountFactor > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<SplineLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< DiscountFactor > *) &((InterpolatedDiscountCurve< SplineLogCubic > const *)arg1)->discounts();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NaturalLogCubicDiscountCurve_nodes(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< SplineLogCubic > *arg1 = (InterpolatedDiscountCurve< SplineLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,DiscountFactor > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<SplineLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedDiscountCurve< SplineLogCubic > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NaturalLogCubicDiscountCurve(void * jarg1) {
  InterpolatedDiscountCurve< SplineLogCubic > *arg1 = (InterpolatedDiscountCurve< SplineLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedDiscountCurve<SplineLogCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<SplineLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogMixedLinearCubicDiscountCurve__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 ;
  LogMixedLinearCubic *arg5 = 0 ;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (LogMixedLinearCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogMixedLinearCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< LogMixedLinearCubic > *)new InterpolatedDiscountCurve< LogMixedLinearCubic >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(LogMixedLinearCubic 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 ? new ext::shared_ptr<  InterpolatedDiscountCurve<LogMixedLinearCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogMixedLinearCubicDiscountCurve__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 ;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< LogMixedLinearCubic > *)new InterpolatedDiscountCurve< LogMixedLinearCubic >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > 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 = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<LogMixedLinearCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogMixedLinearCubicDiscountCurve__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< DiscountFactor > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedDiscountCurve< LogMixedLinearCubic > *)new InterpolatedDiscountCurve< LogMixedLinearCubic >((std::vector< Date > const &)*arg1,(std::vector< DiscountFactor > 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 = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<LogMixedLinearCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogMixedLinearCubicDiscountCurve_times(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *arg1 = (InterpolatedDiscountCurve< LogMixedLinearCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<LogMixedLinearCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((InterpolatedDiscountCurve< LogMixedLinearCubic > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogMixedLinearCubicDiscountCurve_data(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *arg1 = (InterpolatedDiscountCurve< LogMixedLinearCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<LogMixedLinearCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedDiscountCurve< LogMixedLinearCubic > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogMixedLinearCubicDiscountCurve_dates(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *arg1 = (InterpolatedDiscountCurve< LogMixedLinearCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<LogMixedLinearCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedDiscountCurve< LogMixedLinearCubic > 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_LogMixedLinearCubicDiscountCurve_discounts(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *arg1 = (InterpolatedDiscountCurve< LogMixedLinearCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > const > *smartarg1 = 0 ;
  std::vector< DiscountFactor > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<LogMixedLinearCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< DiscountFactor > *) &((InterpolatedDiscountCurve< LogMixedLinearCubic > const *)arg1)->discounts();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogMixedLinearCubicDiscountCurve_nodes(void * jarg1) {
  void * jresult ;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *arg1 = (InterpolatedDiscountCurve< LogMixedLinearCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,DiscountFactor > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<LogMixedLinearCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedDiscountCurve< LogMixedLinearCubic > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LogMixedLinearCubicDiscountCurve(void * jarg1) {
  InterpolatedDiscountCurve< LogMixedLinearCubic > *arg1 = (InterpolatedDiscountCurve< LogMixedLinearCubic > *) 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedDiscountCurve<LogMixedLinearCubic> > *)jarg1;
  arg1 = (InterpolatedDiscountCurve<LogMixedLinearCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & 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 & 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(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 & 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 & is null", 0);
    return 0;
  } 
  arg2 = (Currency *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & 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 & 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(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 & is null", 0);
    return 0;
  } 
  arg2 = (ExchangeRate *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ExchangeRate const & 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(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 & is null", 0);
    return ;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return ;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & is null", 0);
    return ;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 & 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 & is null", 0);
    return 0;
  } 
  arg3 = (Currency *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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(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 & is null", 0);
    return 0;
  } 
  arg3 = (Currency *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Currency const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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(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_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(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 & 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_Settings_setEnforcesTodaysHistoricFixings(void * jarg1, unsigned int jarg2) {
  Settings *arg1 = (Settings *) 0 ;
  bool arg2 ;
  
  arg1 = (Settings *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      Settings_setEnforcesTodaysHistoricFixings(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 unsigned int SWIGSTDCALL CSharp_QuantLib_Settings_getEnforcesTodaysHistoricFixings(void * jarg1) {
  unsigned int jresult ;
  Settings *arg1 = (Settings *) 0 ;
  bool result;
  
  arg1 = (Settings *)jarg1; 
  {
    try {
      result = (bool)Settings_getEnforcesTodaysHistoricFixings(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_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 void * SWIGSTDCALL CSharp_QuantLib_new_Fdm1dMesher(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  Fdm1dMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (Fdm1dMesher *)new Fdm1dMesher(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  Fdm1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_Fdm1dMesher_size(void * jarg1) {
  unsigned long jresult ;
  Fdm1dMesher *arg1 = (Fdm1dMesher *) 0 ;
  ext::shared_ptr< Fdm1dMesher const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm1dMesher > *)jarg1;
  arg1 = (Fdm1dMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Fdm1dMesher 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_Fdm1dMesher_dplus(void * jarg1, unsigned long jarg2) {
  double jresult ;
  Fdm1dMesher *arg1 = (Fdm1dMesher *) 0 ;
  Size arg2 ;
  ext::shared_ptr< Fdm1dMesher const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm1dMesher > *)jarg1;
  arg1 = (Fdm1dMesher *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Real)((Fdm1dMesher const *)arg1)->dplus(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Fdm1dMesher_dminus(void * jarg1, unsigned long jarg2) {
  double jresult ;
  Fdm1dMesher *arg1 = (Fdm1dMesher *) 0 ;
  Size arg2 ;
  ext::shared_ptr< Fdm1dMesher const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm1dMesher > *)jarg1;
  arg1 = (Fdm1dMesher *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Real)((Fdm1dMesher const *)arg1)->dminus(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Fdm1dMesher_location(void * jarg1, unsigned long jarg2) {
  double jresult ;
  Fdm1dMesher *arg1 = (Fdm1dMesher *) 0 ;
  Size arg2 ;
  ext::shared_ptr< Fdm1dMesher const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm1dMesher > *)jarg1;
  arg1 = (Fdm1dMesher *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Real)((Fdm1dMesher const *)arg1)->location(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Fdm1dMesher_locations(void * jarg1) {
  void * jresult ;
  Fdm1dMesher *arg1 = (Fdm1dMesher *) 0 ;
  ext::shared_ptr< Fdm1dMesher > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Fdm1dMesher > *)jarg1;
  arg1 = (Fdm1dMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &(arg1)->locations();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Fdm1dMesher(void * jarg1) {
  Fdm1dMesher *arg1 = (Fdm1dMesher *) 0 ;
  ext::shared_ptr< Fdm1dMesher > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Fdm1dMesher > *)jarg1;
  arg1 = (Fdm1dMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Fdm1dMesherVector_Clear(void * jarg1) {
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)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_Fdm1dMesherVector_Add(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg2 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Fdm1dMesher > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::shared_ptr< Fdm1dMesher > 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_Fdm1dMesherVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< Fdm1dMesher > > 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_Fdm1dMesherVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< Fdm1dMesher > > 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_Fdm1dMesherVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< Fdm1dMesher > >::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_Fdm1dMesherVector__SWIG_0() {
  void * jresult ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)new std::vector< ext::shared_ptr< Fdm1dMesher > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fdm1dMesherVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)new_std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_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_Fdm1dMesherVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< Fdm1dMesher > result;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_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 = result ? new ext::shared_ptr< Fdm1dMesher >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Fdm1dMesherVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_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 = *result ? new std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Fdm1dMesherVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< Fdm1dMesher > *arg3 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< Fdm1dMesher > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__setitem(arg1,arg2,(ext::shared_ptr< Fdm1dMesher > 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_Fdm1dMesherVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Fdm1dMesher > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__AddRange(arg1,(std::vector< ext::shared_ptr< Fdm1dMesher > > 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_Fdm1dMesherVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_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_Fdm1dMesherVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< Fdm1dMesher > *arg3 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< Fdm1dMesher > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__Insert(arg1,arg2,(ext::shared_ptr< Fdm1dMesher > 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_Fdm1dMesherVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Fdm1dMesher > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::shared_ptr< Fdm1dMesher > > 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_Fdm1dMesherVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_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_Fdm1dMesherVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_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_Fdm1dMesherVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< Fdm1dMesher > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< Fdm1dMesher > tempnull1 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Fdm1dMesher > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__Repeat((ext::shared_ptr< Fdm1dMesher > 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_Fdm1dMesherVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_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_Fdm1dMesherVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_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_Fdm1dMesherVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Fdm1dMesher > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::shared_ptr< Fdm1dMesher > > 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_Fdm1dMesherVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg2 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Fdm1dMesher > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__Contains(arg1,(ext::shared_ptr< Fdm1dMesher > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_Fdm1dMesherVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg2 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Fdm1dMesher > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__IndexOf(arg1,(ext::shared_ptr< Fdm1dMesher > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_Fdm1dMesherVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg2 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Fdm1dMesher > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__LastIndexOf(arg1,(ext::shared_ptr< Fdm1dMesher > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_Fdm1dMesherVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg2 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< Fdm1dMesher > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__Remove(arg1,(ext::shared_ptr< Fdm1dMesher > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_Fdm1dMesherVector(void * jarg1) {
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesMesher__SWIG_0(unsigned long jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, void * jarg9, void * jarg10, void * jarg11, double jarg12) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  doubleOrNull arg5 ;
  doubleOrNull arg6 ;
  Real arg7 ;
  Real arg8 ;
  std::pair< Real,Real > *arg9 = 0 ;
  std::vector< ext::shared_ptr< Dividend > > *arg10 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg11 = 0 ;
  Real arg12 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull11 ;
  FdmBlackScholesMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (std::pair< Real,Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Real,Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< ext::shared_ptr< Dividend > > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Dividend > > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg11 : &tempnull11; 
  arg12 = (Real)jarg12; 
  {
    try {
      result = (FdmBlackScholesMesher *)new FdmBlackScholesMesher(arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,(std::pair< Real,Real > const &)*arg9,(std::vector< ext::shared_ptr< Dividend > > const &)*arg10,(ext::shared_ptr< FdmQuantoHelper > 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 = result ? new ext::shared_ptr<  FdmBlackScholesMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesMesher__SWIG_1(unsigned long jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, void * jarg9, void * jarg10, void * jarg11) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  doubleOrNull arg5 ;
  doubleOrNull arg6 ;
  Real arg7 ;
  Real arg8 ;
  std::pair< Real,Real > *arg9 = 0 ;
  std::vector< ext::shared_ptr< Dividend > > *arg10 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg11 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull11 ;
  FdmBlackScholesMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (std::pair< Real,Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Real,Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< ext::shared_ptr< Dividend > > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Dividend > > const & is null", 0);
    return 0;
  } 
  arg11 = jarg11 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg11 : &tempnull11; 
  {
    try {
      result = (FdmBlackScholesMesher *)new FdmBlackScholesMesher(arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,(std::pair< Real,Real > const &)*arg9,(std::vector< ext::shared_ptr< Dividend > > const &)*arg10,(ext::shared_ptr< FdmQuantoHelper > 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 = result ? new ext::shared_ptr<  FdmBlackScholesMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesMesher__SWIG_2(unsigned long jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  doubleOrNull arg5 ;
  doubleOrNull arg6 ;
  Real arg7 ;
  Real arg8 ;
  std::pair< Real,Real > *arg9 = 0 ;
  std::vector< ext::shared_ptr< Dividend > > *arg10 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  FdmBlackScholesMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (std::pair< Real,Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Real,Real > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< ext::shared_ptr< Dividend > > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Dividend > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmBlackScholesMesher *)new FdmBlackScholesMesher(arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,(std::pair< Real,Real > const &)*arg9,(std::vector< ext::shared_ptr< Dividend > > 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 = result ? new ext::shared_ptr<  FdmBlackScholesMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesMesher__SWIG_3(unsigned long jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, void * jarg9) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  doubleOrNull arg5 ;
  doubleOrNull arg6 ;
  Real arg7 ;
  Real arg8 ;
  std::pair< Real,Real > *arg9 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  FdmBlackScholesMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (std::pair< Real,Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Real,Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmBlackScholesMesher *)new FdmBlackScholesMesher(arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,(std::pair< Real,Real > 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 ? new ext::shared_ptr<  FdmBlackScholesMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesMesher__SWIG_4(unsigned long jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  doubleOrNull arg5 ;
  doubleOrNull arg6 ;
  Real arg7 ;
  Real arg8 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  FdmBlackScholesMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (FdmBlackScholesMesher *)new FdmBlackScholesMesher(arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  FdmBlackScholesMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesMesher__SWIG_5(unsigned long jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  doubleOrNull arg5 ;
  doubleOrNull arg6 ;
  Real arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  FdmBlackScholesMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (FdmBlackScholesMesher *)new FdmBlackScholesMesher(arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 = result ? new ext::shared_ptr<  FdmBlackScholesMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesMesher__SWIG_6(unsigned long jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  doubleOrNull arg5 ;
  doubleOrNull arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  FdmBlackScholesMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  {
    try {
      result = (FdmBlackScholesMesher *)new FdmBlackScholesMesher(arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdmBlackScholesMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesMesher__SWIG_7(unsigned long jarg1, void * jarg2, double jarg3, double jarg4, double jarg5) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  doubleOrNull arg5 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  FdmBlackScholesMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (doubleOrNull)jarg5; 
  {
    try {
      result = (FdmBlackScholesMesher *)new FdmBlackScholesMesher(arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdmBlackScholesMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesMesher__SWIG_8(unsigned long jarg1, void * jarg2, double jarg3, double jarg4) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  FdmBlackScholesMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (FdmBlackScholesMesher *)new FdmBlackScholesMesher(arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdmBlackScholesMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmBlackScholesMesher_processHelper(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > result;
  
  arg1 = (Handle< Quote > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  {
    try {
      result = FdmBlackScholesMesher::processHelper((Handle< Quote > 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 = result ? new ext::shared_ptr< GeneralizedBlackScholesProcess >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmBlackScholesMesher(void * jarg1) {
  FdmBlackScholesMesher *arg1 = (FdmBlackScholesMesher *) 0 ;
  ext::shared_ptr< FdmBlackScholesMesher > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmBlackScholesMesher > *)jarg1;
  arg1 = (FdmBlackScholesMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Concentrating1dMesherPoint(double jarg1, double jarg2, unsigned int jarg3) {
  void * jresult ;
  double arg1 ;
  double arg2 ;
  bool arg3 ;
  ext::tuple< Real,Real,bool > *result = 0 ;
  
  arg1 = (double)jarg1; 
  arg2 = (double)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = (ext::tuple< Real,Real,bool > *)new ext::tuple< Real,Real,bool >(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_Concentrating1dMesherPoint_first(void * jarg1) {
  double jresult ;
  ext::tuple< Real,Real,bool > *arg1 = (ext::tuple< Real,Real,bool > *) 0 ;
  double result;
  
  arg1 = (ext::tuple< Real,Real,bool > *)jarg1; 
  {
    try {
      result = (double)ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__first((ext::tuple< double,double,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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Concentrating1dMesherPoint_second(void * jarg1) {
  double jresult ;
  ext::tuple< Real,Real,bool > *arg1 = (ext::tuple< Real,Real,bool > *) 0 ;
  double result;
  
  arg1 = (ext::tuple< Real,Real,bool > *)jarg1; 
  {
    try {
      result = (double)ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__second((ext::tuple< double,double,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 = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_Concentrating1dMesherPoint_third(void * jarg1) {
  unsigned int jresult ;
  ext::tuple< Real,Real,bool > *arg1 = (ext::tuple< Real,Real,bool > *) 0 ;
  bool result;
  
  arg1 = (ext::tuple< Real,Real,bool > *)jarg1; 
  {
    try {
      result = (bool)ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__third((ext::tuple< double,double,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 = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Concentrating1dMesherPoint(void * jarg1) {
  ext::tuple< Real,Real,bool > *arg1 = (ext::tuple< Real,Real,bool > *) 0 ;
  
  arg1 = (ext::tuple< Real,Real,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_Concentrating1dMesherPointVector_Clear(void * jarg1) {
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  
  arg1 = (std::vector< ext::tuple< Real,Real,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_Concentrating1dMesherPointVector_Add(void * jarg1, void * jarg2) {
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  ext::tuple< Real,Real,bool > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1; 
  arg2 = (ext::tuple< Real,Real,bool > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ext::tuple< Real,Real,bool > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->push_back((ext::tuple< Real,Real,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_Concentrating1dMesherPointVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< double,double,bool > >::size_type result;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::tuple< Real,Real,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_Concentrating1dMesherPointVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< double,double,bool > >::size_type result;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::tuple< Real,Real,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_Concentrating1dMesherPointVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< double,double,bool > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1; 
  arg2 = (std::vector< ext::tuple< double,double,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_Concentrating1dMesherPointVector__SWIG_0() {
  void * jresult ;
  std::vector< ext::tuple< Real,Real,bool > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::tuple< Real,Real,bool > > *)new std::vector< ext::tuple< Real,Real,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_Concentrating1dMesherPointVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = 0 ;
  std::vector< ext::tuple< Real,Real,bool > > *result = 0 ;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::tuple< Real,Real,bool > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< ext::tuple< Real,Real,bool > > *)new std::vector< ext::tuple< Real,Real,bool > >((std::vector< ext::tuple< Real,Real,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_Concentrating1dMesherPointVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< ext::tuple< Real,Real,bool > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::tuple< Real,Real,bool > > *)new_std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_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_Concentrating1dMesherPointVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  int arg2 ;
  SwigValueWrapper< ext::tuple< double,double,bool > > result;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_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 ext::tuple< Real,Real,bool >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Concentrating1dMesherPointVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  int arg2 ;
  std::vector< ext::tuple< double,double,bool > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::tuple< double,double,bool > >::value_type *) &std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_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_Concentrating1dMesherPointVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  int arg2 ;
  ext::tuple< Real,Real,bool > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (ext::tuple< Real,Real,bool > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ext::tuple< Real,Real,bool > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__setitem(arg1,arg2,(ext::tuple< double,double,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_Concentrating1dMesherPointVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< Real,Real,bool > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1; 
  arg2 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::tuple< Real,Real,bool > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__AddRange(arg1,(std::vector< ext::tuple< double,double,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_Concentrating1dMesherPointVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::tuple< Real,Real,bool > > *result = 0 ;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::tuple< Real,Real,bool > > *)std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_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_Concentrating1dMesherPointVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  int arg2 ;
  ext::tuple< Real,Real,bool > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (ext::tuple< Real,Real,bool > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ext::tuple< Real,Real,bool > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__Insert(arg1,arg2,(ext::tuple< double,double,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_Concentrating1dMesherPointVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  int arg2 ;
  std::vector< ext::tuple< Real,Real,bool > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::tuple< Real,Real,bool > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::tuple< double,double,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_Concentrating1dMesherPointVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_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_Concentrating1dMesherPointVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_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_Concentrating1dMesherPointVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  ext::tuple< Real,Real,bool > *arg1 = 0 ;
  int arg2 ;
  std::vector< ext::tuple< Real,Real,bool > > *result = 0 ;
  
  arg1 = (ext::tuple< Real,Real,bool > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "ext::tuple< Real,Real,bool > const & is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::tuple< Real,Real,bool > > *)std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__Repeat((ext::tuple< double,double,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_Concentrating1dMesherPointVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_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_Concentrating1dMesherPointVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_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_Concentrating1dMesherPointVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  int arg2 ;
  std::vector< ext::tuple< Real,Real,bool > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::tuple< Real,Real,bool > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::tuple< double,double,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_delete_Concentrating1dMesherPointVector(void * jarg1) {
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  
  arg1 = (std::vector< ext::tuple< Real,Real,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_Concentrating1dMesher__SWIG_0(double jarg1, double jarg2, unsigned long jarg3, void * jarg4, unsigned int jarg5) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  std::pair< Real,Real > *arg4 = 0 ;
  bool arg5 ;
  Concentrating1dMesher *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (std::pair< Real,Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Real,Real > const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Concentrating1dMesher *)new Concentrating1dMesher(arg1,arg2,arg3,(std::pair< Real,Real > 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 ? new ext::shared_ptr<  Concentrating1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Concentrating1dMesher__SWIG_1(double jarg1, double jarg2, unsigned long jarg3, void * jarg4) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  std::pair< Real,Real > *arg4 = 0 ;
  Concentrating1dMesher *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (std::pair< Real,Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Real,Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Concentrating1dMesher *)new Concentrating1dMesher(arg1,arg2,arg3,(std::pair< Real,Real > 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 ? new ext::shared_ptr<  Concentrating1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Concentrating1dMesher__SWIG_2(double jarg1, double jarg2, unsigned long jarg3) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  Concentrating1dMesher *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (Concentrating1dMesher *)new Concentrating1dMesher(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 ? new ext::shared_ptr<  Concentrating1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Concentrating1dMesher__SWIG_3(double jarg1, double jarg2, unsigned long jarg3, void * jarg4, double jarg5) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  std::vector< ext::tuple< Real,Real,bool > > *arg4 = 0 ;
  Real arg5 ;
  Concentrating1dMesher *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::tuple< Real,Real,bool > > const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Concentrating1dMesher *)new Concentrating1dMesher(arg1,arg2,arg3,(std::vector< ext::tuple< Real,Real,bool > > 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 ? new ext::shared_ptr<  Concentrating1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Concentrating1dMesher__SWIG_4(double jarg1, double jarg2, unsigned long jarg3, void * jarg4) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  std::vector< ext::tuple< Real,Real,bool > > *arg4 = 0 ;
  Concentrating1dMesher *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (std::vector< ext::tuple< Real,Real,bool > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::tuple< Real,Real,bool > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Concentrating1dMesher *)new Concentrating1dMesher(arg1,arg2,arg3,(std::vector< ext::tuple< Real,Real,bool > > 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 ? new ext::shared_ptr<  Concentrating1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Concentrating1dMesher(void * jarg1) {
  Concentrating1dMesher *arg1 = (Concentrating1dMesher *) 0 ;
  ext::shared_ptr< Concentrating1dMesher > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Concentrating1dMesher > *)jarg1;
  arg1 = (Concentrating1dMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialJump1dMesher__SWIG_0(unsigned long jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  ExponentialJump1dMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (ExponentialJump1dMesher *)new ExponentialJump1dMesher(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 ? new ext::shared_ptr<  ExponentialJump1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialJump1dMesher__SWIG_1(unsigned long jarg1, double jarg2, double jarg3, double jarg4) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  ExponentialJump1dMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (ExponentialJump1dMesher *)new ExponentialJump1dMesher(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 ? new ext::shared_ptr<  ExponentialJump1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ExponentialJump1dMesher(void * jarg1) {
  ExponentialJump1dMesher *arg1 = (ExponentialJump1dMesher *) 0 ;
  ext::shared_ptr< ExponentialJump1dMesher > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ExponentialJump1dMesher > *)jarg1;
  arg1 = (ExponentialJump1dMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmCEV1dMesher__SWIG_0(unsigned long jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, void * jarg8) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Time arg5 ;
  Real arg6 ;
  Real arg7 ;
  std::pair< Real,Real > *arg8 = 0 ;
  FdmCEV1dMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Time)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (std::pair< Real,Real > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Real,Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmCEV1dMesher *)new FdmCEV1dMesher(arg1,arg2,arg3,arg4,arg5,arg6,arg7,(std::pair< Real,Real > 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 ? new ext::shared_ptr<  FdmCEV1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmCEV1dMesher__SWIG_1(unsigned long jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Time arg5 ;
  Real arg6 ;
  Real arg7 ;
  FdmCEV1dMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Time)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (FdmCEV1dMesher *)new FdmCEV1dMesher(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 ? new ext::shared_ptr<  FdmCEV1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmCEV1dMesher__SWIG_2(unsigned long jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Time arg5 ;
  Real arg6 ;
  FdmCEV1dMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Time)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (FdmCEV1dMesher *)new FdmCEV1dMesher(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 ? new ext::shared_ptr<  FdmCEV1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmCEV1dMesher__SWIG_3(unsigned long jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Time arg5 ;
  FdmCEV1dMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Time)jarg5; 
  {
    try {
      result = (FdmCEV1dMesher *)new FdmCEV1dMesher(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 ? new ext::shared_ptr<  FdmCEV1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmCEV1dMesher(void * jarg1) {
  FdmCEV1dMesher *arg1 = (FdmCEV1dMesher *) 0 ;
  ext::shared_ptr< FdmCEV1dMesher > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmCEV1dMesher > *)jarg1;
  arg1 = (FdmCEV1dMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonVarianceMesher__SWIG_0(unsigned long jarg1, void * jarg2, double jarg3, unsigned long jarg4, double jarg5) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  Time arg3 ;
  Size arg4 ;
  Real arg5 ;
  ext::shared_ptr< HestonProcess > tempnull2 ;
  FdmHestonVarianceMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonProcess > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (FdmHestonVarianceMesher *)new FdmHestonVarianceMesher(arg1,(ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  FdmHestonVarianceMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonVarianceMesher__SWIG_1(unsigned long jarg1, void * jarg2, double jarg3, unsigned long jarg4) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  Time arg3 ;
  Size arg4 ;
  ext::shared_ptr< HestonProcess > tempnull2 ;
  FdmHestonVarianceMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonProcess > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdmHestonVarianceMesher *)new FdmHestonVarianceMesher(arg1,(ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  FdmHestonVarianceMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonVarianceMesher__SWIG_2(unsigned long jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< HestonProcess > tempnull2 ;
  FdmHestonVarianceMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonProcess > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (FdmHestonVarianceMesher *)new FdmHestonVarianceMesher(arg1,(ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  FdmHestonVarianceMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FdmHestonVarianceMesher_volaEstimate(void * jarg1) {
  double jresult ;
  FdmHestonVarianceMesher *arg1 = (FdmHestonVarianceMesher *) 0 ;
  ext::shared_ptr< FdmHestonVarianceMesher const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmHestonVarianceMesher > *)jarg1;
  arg1 = (FdmHestonVarianceMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((FdmHestonVarianceMesher const *)arg1)->volaEstimate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_FdmHestonVarianceMesher(void * jarg1) {
  FdmHestonVarianceMesher *arg1 = (FdmHestonVarianceMesher *) 0 ;
  ext::shared_ptr< FdmHestonVarianceMesher > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmHestonVarianceMesher > *)jarg1;
  arg1 = (FdmHestonVarianceMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonLocalVolatilityVarianceMesher__SWIG_0(unsigned long jarg1, void * jarg2, void * jarg3, double jarg4, unsigned long jarg5, double jarg6) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg3 = 0 ;
  Time arg4 ;
  Size arg5 ;
  Real arg6 ;
  ext::shared_ptr< HestonProcess > tempnull2 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull3 ;
  FdmHestonLocalVolatilityVarianceMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonProcess > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg3 : &tempnull3; 
  arg4 = (Time)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (FdmHestonLocalVolatilityVarianceMesher *)new FdmHestonLocalVolatilityVarianceMesher(arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdmHestonLocalVolatilityVarianceMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonLocalVolatilityVarianceMesher__SWIG_1(unsigned long jarg1, void * jarg2, void * jarg3, double jarg4, unsigned long jarg5) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg3 = 0 ;
  Time arg4 ;
  Size arg5 ;
  ext::shared_ptr< HestonProcess > tempnull2 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull3 ;
  FdmHestonLocalVolatilityVarianceMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonProcess > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg3 : &tempnull3; 
  arg4 = (Time)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdmHestonLocalVolatilityVarianceMesher *)new FdmHestonLocalVolatilityVarianceMesher(arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdmHestonLocalVolatilityVarianceMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonLocalVolatilityVarianceMesher__SWIG_2(unsigned long jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg3 = 0 ;
  Time arg4 ;
  ext::shared_ptr< HestonProcess > tempnull2 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull3 ;
  FdmHestonLocalVolatilityVarianceMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonProcess > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg3 : &tempnull3; 
  arg4 = (Time)jarg4; 
  {
    try {
      result = (FdmHestonLocalVolatilityVarianceMesher *)new FdmHestonLocalVolatilityVarianceMesher(arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdmHestonLocalVolatilityVarianceMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FdmHestonLocalVolatilityVarianceMesher_volaEstimate(void * jarg1) {
  double jresult ;
  FdmHestonLocalVolatilityVarianceMesher *arg1 = (FdmHestonLocalVolatilityVarianceMesher *) 0 ;
  ext::shared_ptr< FdmHestonLocalVolatilityVarianceMesher const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmHestonLocalVolatilityVarianceMesher > *)jarg1;
  arg1 = (FdmHestonLocalVolatilityVarianceMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((FdmHestonLocalVolatilityVarianceMesher const *)arg1)->volaEstimate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_FdmHestonLocalVolatilityVarianceMesher(void * jarg1) {
  FdmHestonLocalVolatilityVarianceMesher *arg1 = (FdmHestonLocalVolatilityVarianceMesher *) 0 ;
  ext::shared_ptr< FdmHestonLocalVolatilityVarianceMesher > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmHestonLocalVolatilityVarianceMesher > *)jarg1;
  arg1 = (FdmHestonLocalVolatilityVarianceMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmSimpleProcess1dMesher__SWIG_0(unsigned long jarg1, void * jarg2, double jarg3, unsigned long jarg4, double jarg5, double jarg6) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< StochasticProcess1D > *arg2 = 0 ;
  Time arg3 ;
  Size arg4 ;
  Real arg5 ;
  doubleOrNull arg6 ;
  ext::shared_ptr< StochasticProcess1D > tempnull2 ;
  FdmSimpleProcess1dMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StochasticProcess1D > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (doubleOrNull)jarg6; 
  {
    try {
      result = (FdmSimpleProcess1dMesher *)new FdmSimpleProcess1dMesher(arg1,(ext::shared_ptr< StochasticProcess1D > 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 ? new ext::shared_ptr<  FdmSimpleProcess1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmSimpleProcess1dMesher__SWIG_1(unsigned long jarg1, void * jarg2, double jarg3, unsigned long jarg4, double jarg5) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< StochasticProcess1D > *arg2 = 0 ;
  Time arg3 ;
  Size arg4 ;
  Real arg5 ;
  ext::shared_ptr< StochasticProcess1D > tempnull2 ;
  FdmSimpleProcess1dMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StochasticProcess1D > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (FdmSimpleProcess1dMesher *)new FdmSimpleProcess1dMesher(arg1,(ext::shared_ptr< StochasticProcess1D > 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 ? new ext::shared_ptr<  FdmSimpleProcess1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmSimpleProcess1dMesher__SWIG_2(unsigned long jarg1, void * jarg2, double jarg3, unsigned long jarg4) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< StochasticProcess1D > *arg2 = 0 ;
  Time arg3 ;
  Size arg4 ;
  ext::shared_ptr< StochasticProcess1D > tempnull2 ;
  FdmSimpleProcess1dMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StochasticProcess1D > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdmSimpleProcess1dMesher *)new FdmSimpleProcess1dMesher(arg1,(ext::shared_ptr< StochasticProcess1D > 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 ? new ext::shared_ptr<  FdmSimpleProcess1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmSimpleProcess1dMesher__SWIG_3(unsigned long jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< StochasticProcess1D > *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< StochasticProcess1D > tempnull2 ;
  FdmSimpleProcess1dMesher *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StochasticProcess1D > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (FdmSimpleProcess1dMesher *)new FdmSimpleProcess1dMesher(arg1,(ext::shared_ptr< StochasticProcess1D > 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 ? new ext::shared_ptr<  FdmSimpleProcess1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmSimpleProcess1dMesher(void * jarg1) {
  FdmSimpleProcess1dMesher *arg1 = (FdmSimpleProcess1dMesher *) 0 ;
  ext::shared_ptr< FdmSimpleProcess1dMesher > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmSimpleProcess1dMesher > *)jarg1;
  arg1 = (FdmSimpleProcess1dMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Uniform1dMesher(double jarg1, double jarg2, unsigned long jarg3) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  Uniform1dMesher *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (Uniform1dMesher *)new Uniform1dMesher(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 ? new ext::shared_ptr<  Uniform1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Uniform1dMesher(void * jarg1) {
  Uniform1dMesher *arg1 = (Uniform1dMesher *) 0 ;
  ext::shared_ptr< Uniform1dMesher > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Uniform1dMesher > *)jarg1;
  arg1 = (Uniform1dMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Predefined1dMesher(void * jarg1) {
  Predefined1dMesher *arg1 = (Predefined1dMesher *) 0 ;
  ext::shared_ptr< Predefined1dMesher > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Predefined1dMesher > *)jarg1;
  arg1 = (Predefined1dMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Glued1dMesher(void * jarg1, void * jarg2) {
  void * jresult ;
  Fdm1dMesher *arg1 = 0 ;
  Fdm1dMesher *arg2 = 0 ;
  Glued1dMesher *result = 0 ;
  
  
  arg1 = (Fdm1dMesher *)(((ext::shared_ptr< const Fdm1dMesher > *)jarg1) ? ((ext::shared_ptr< const Fdm1dMesher > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Fdm1dMesher const & reference is null", 0);
    return 0;
  } 
  
  arg2 = (Fdm1dMesher *)(((ext::shared_ptr< const Fdm1dMesher > *)jarg2) ? ((ext::shared_ptr< const Fdm1dMesher > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Fdm1dMesher const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (Glued1dMesher *)new Glued1dMesher((Fdm1dMesher const &)*arg1,(Fdm1dMesher const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  Glued1dMesher >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Glued1dMesher(void * jarg1) {
  Glued1dMesher *arg1 = (Glued1dMesher *) 0 ;
  ext::shared_ptr< Glued1dMesher > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Glued1dMesher > *)jarg1;
  arg1 = (Glued1dMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmLinearOpIterator__SWIG_0(void * jarg1) {
  void * jresult ;
  std::vector< unsigned int > *arg1 = 0 ;
  FdmLinearOpIterator *result = 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmLinearOpIterator *)new_FdmLinearOpIterator__SWIG_0((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_FdmLinearOpIterator__SWIG_1(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int > *arg2 = 0 ;
  Size arg3 ;
  FdmLinearOpIterator *result = 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< unsigned int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & is null", 0);
    return 0;
  } 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdmLinearOpIterator *)new_FdmLinearOpIterator__SWIG_1((std::vector< unsigned int > const &)*arg1,(std::vector< unsigned int > const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpIterator_coordinates(void * jarg1) {
  void * jresult ;
  FdmLinearOpIterator *arg1 = (FdmLinearOpIterator *) 0 ;
  std::vector< unsigned int > result;
  
  arg1 = (FdmLinearOpIterator *)jarg1; 
  {
    try {
      result = FdmLinearOpIterator_coordinates(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FdmLinearOpIterator_increment(void * jarg1) {
  FdmLinearOpIterator *arg1 = (FdmLinearOpIterator *) 0 ;
  
  arg1 = (FdmLinearOpIterator *)jarg1; 
  {
    try {
      FdmLinearOpIterator_increment(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_FdmLinearOpIterator_notEqual(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  FdmLinearOpIterator *arg1 = (FdmLinearOpIterator *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  bool result;
  
  arg1 = (FdmLinearOpIterator *)jarg1; 
  arg2 = (FdmLinearOpIterator *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmLinearOpIterator const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)FdmLinearOpIterator_notEqual(arg1,(FdmLinearOpIterator const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_FdmLinearOpIterator_index(void * jarg1) {
  unsigned long jresult ;
  FdmLinearOpIterator *arg1 = (FdmLinearOpIterator *) 0 ;
  Size result;
  
  arg1 = (FdmLinearOpIterator *)jarg1; 
  {
    try {
      result = ((FdmLinearOpIterator const *)arg1)->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 = (unsigned long)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmLinearOpLayout(void * jarg1) {
  void * jresult ;
  std::vector< unsigned int > *arg1 = 0 ;
  FdmLinearOpLayout *result = 0 ;
  
  arg1 = (std::vector< unsigned int > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmLinearOpLayout *)new_FdmLinearOpLayout((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 = result ? new ext::shared_ptr<  FdmLinearOpLayout >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpLayout_spacing(void * jarg1) {
  void * jresult ;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  ext::shared_ptr< FdmLinearOpLayout > *smartarg1 = 0 ;
  std::vector< unsigned int > result;
  
  
  smartarg1 = (ext::shared_ptr<  FdmLinearOpLayout > *)jarg1;
  arg1 = (FdmLinearOpLayout *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = FdmLinearOpLayout_spacing(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpLayout_dim(void * jarg1) {
  void * jresult ;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  ext::shared_ptr< FdmLinearOpLayout const > *smartarg1 = 0 ;
  std::vector< unsigned int > result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmLinearOpLayout > *)jarg1;
  arg1 = (FdmLinearOpLayout *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = FdmLinearOpLayout_dim((FdmLinearOpLayout const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_FdmLinearOpLayout_index(void * jarg1, void * jarg2) {
  unsigned long jresult ;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  std::vector< unsigned int > *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpLayout const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmLinearOpLayout > *)jarg1;
  arg1 = (FdmLinearOpLayout *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< unsigned int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = FdmLinearOpLayout_index((FdmLinearOpLayout const *)arg1,(std::vector< 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 = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpLayout_begin(void * jarg1) {
  void * jresult ;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  ext::shared_ptr< FdmLinearOpLayout const > *smartarg1 = 0 ;
  SwigValueWrapper< FdmLinearOpIterator > result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmLinearOpLayout > *)jarg1;
  arg1 = (FdmLinearOpLayout *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((FdmLinearOpLayout const *)arg1)->begin();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new FdmLinearOpIterator(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpLayout_end(void * jarg1) {
  void * jresult ;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  ext::shared_ptr< FdmLinearOpLayout const > *smartarg1 = 0 ;
  SwigValueWrapper< FdmLinearOpIterator > result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmLinearOpLayout > *)jarg1;
  arg1 = (FdmLinearOpLayout *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((FdmLinearOpLayout const *)arg1)->end();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new FdmLinearOpIterator(result); 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_FdmLinearOpLayout_size(void * jarg1) {
  unsigned long jresult ;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  ext::shared_ptr< FdmLinearOpLayout const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmLinearOpLayout > *)jarg1;
  arg1 = (FdmLinearOpLayout *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((FdmLinearOpLayout 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_FdmLinearOpLayout_neighbourhood__SWIG_0(void * jarg1, void * jarg2, unsigned long jarg3, int jarg4) {
  unsigned long jresult ;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Size arg3 ;
  Integer arg4 ;
  ext::shared_ptr< FdmLinearOpLayout const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmLinearOpLayout > *)jarg1;
  arg1 = (FdmLinearOpLayout *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (FdmLinearOpIterator *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmLinearOpIterator const & is null", 0);
    return 0;
  } 
  arg3 = (Size)jarg3; 
  arg4 = (Integer)jarg4; 
  {
    try {
      result = ((FdmLinearOpLayout const *)arg1)->neighbourhood((FdmLinearOpIterator 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 = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_FdmLinearOpLayout_neighbourhood__SWIG_1(void * jarg1, void * jarg2, unsigned long jarg3, int jarg4, unsigned long jarg5, int jarg6) {
  unsigned long jresult ;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Size arg3 ;
  Integer arg4 ;
  Size arg5 ;
  Integer arg6 ;
  ext::shared_ptr< FdmLinearOpLayout const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmLinearOpLayout > *)jarg1;
  arg1 = (FdmLinearOpLayout *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (FdmLinearOpIterator *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmLinearOpIterator const & is null", 0);
    return 0;
  } 
  arg3 = (Size)jarg3; 
  arg4 = (Integer)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Integer)jarg6; 
  {
    try {
      result = ((FdmLinearOpLayout const *)arg1)->neighbourhood((FdmLinearOpIterator 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 = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpLayout_iter_neighbourhood(void * jarg1, void * jarg2, unsigned long jarg3, int jarg4) {
  void * jresult ;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Size arg3 ;
  Integer arg4 ;
  ext::shared_ptr< FdmLinearOpLayout const > *smartarg1 = 0 ;
  SwigValueWrapper< FdmLinearOpIterator > result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmLinearOpLayout > *)jarg1;
  arg1 = (FdmLinearOpLayout *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (FdmLinearOpIterator *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmLinearOpIterator const & is null", 0);
    return 0;
  } 
  arg3 = (Size)jarg3; 
  arg4 = (Integer)jarg4; 
  {
    try {
      result = ((FdmLinearOpLayout const *)arg1)->iter_neighbourhood((FdmLinearOpIterator 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 FdmLinearOpIterator(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmLinearOpLayout(void * jarg1) {
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  ext::shared_ptr< FdmLinearOpLayout > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmLinearOpLayout > *)jarg1;
  arg1 = (FdmLinearOpLayout *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_FdmMesher_dplus(void * jarg1, void * jarg2, unsigned long jarg3) {
  double jresult ;
  FdmMesher *arg1 = (FdmMesher *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Size arg3 ;
  ext::shared_ptr< FdmMesher const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmMesher > *)jarg1;
  arg1 = (FdmMesher *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (FdmLinearOpIterator *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmLinearOpIterator const & is null", 0);
    return 0;
  } 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (Real)((FdmMesher const *)arg1)->dplus((FdmLinearOpIterator 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_FdmMesher_dminus(void * jarg1, void * jarg2, unsigned long jarg3) {
  double jresult ;
  FdmMesher *arg1 = (FdmMesher *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Size arg3 ;
  ext::shared_ptr< FdmMesher const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmMesher > *)jarg1;
  arg1 = (FdmMesher *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (FdmLinearOpIterator *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmLinearOpIterator const & is null", 0);
    return 0;
  } 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (Real)((FdmMesher const *)arg1)->dminus((FdmLinearOpIterator 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_FdmMesher_location(void * jarg1, void * jarg2, unsigned long jarg3) {
  double jresult ;
  FdmMesher *arg1 = (FdmMesher *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Size arg3 ;
  ext::shared_ptr< FdmMesher const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmMesher > *)jarg1;
  arg1 = (FdmMesher *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (FdmLinearOpIterator *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmLinearOpIterator const & is null", 0);
    return 0;
  } 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (Real)((FdmMesher const *)arg1)->location((FdmLinearOpIterator 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 void * SWIGSTDCALL CSharp_QuantLib_FdmMesher_locations(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  FdmMesher *arg1 = (FdmMesher *) 0 ;
  Size arg2 ;
  ext::shared_ptr< FdmMesher const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmMesher > *)jarg1;
  arg1 = (FdmMesher *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = ((FdmMesher const *)arg1)->locations(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmMesher_layout(void * jarg1) {
  void * jresult ;
  FdmMesher *arg1 = (FdmMesher *) 0 ;
  ext::shared_ptr< FdmMesher const > *smartarg1 = 0 ;
  ext::shared_ptr< FdmLinearOpLayout > result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmMesher > *)jarg1;
  arg1 = (FdmMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((FdmMesher const *)arg1)->layout();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< FdmLinearOpLayout >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmMesher(void * jarg1) {
  FdmMesher *arg1 = (FdmMesher *) 0 ;
  ext::shared_ptr< FdmMesher > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmMesher > *)jarg1;
  arg1 = (FdmMesher *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmMesherComposite__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< FdmLinearOpLayout > *arg1 = 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpLayout > tempnull1 ;
  FdmMesherComposite *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmLinearOpLayout > *)jarg1 : &tempnull1; 
  arg2 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Fdm1dMesher > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmMesherComposite *)new FdmMesherComposite((ext::shared_ptr< FdmLinearOpLayout > const &)*arg1,(std::vector< ext::shared_ptr< Fdm1dMesher > > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdmMesherComposite >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmMesherComposite__SWIG_2(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< Fdm1dMesher > *arg1 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempnull1 ;
  FdmMesherComposite *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Fdm1dMesher > *)jarg1 : &tempnull1; 
  {
    try {
      result = (FdmMesherComposite *)new FdmMesherComposite((ext::shared_ptr< Fdm1dMesher > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdmMesherComposite >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmMesherComposite__SWIG_3(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< Fdm1dMesher > *arg1 = 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg2 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempnull1 ;
  ext::shared_ptr< Fdm1dMesher > tempnull2 ;
  FdmMesherComposite *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Fdm1dMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Fdm1dMesher > *)jarg2 : &tempnull2; 
  {
    try {
      result = (FdmMesherComposite *)new FdmMesherComposite((ext::shared_ptr< Fdm1dMesher > const &)*arg1,(ext::shared_ptr< Fdm1dMesher > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdmMesherComposite >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmMesherComposite__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< Fdm1dMesher > *arg1 = 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg2 = 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg3 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempnull1 ;
  ext::shared_ptr< Fdm1dMesher > tempnull2 ;
  ext::shared_ptr< Fdm1dMesher > tempnull3 ;
  FdmMesherComposite *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Fdm1dMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Fdm1dMesher > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< Fdm1dMesher > *)jarg3 : &tempnull3; 
  {
    try {
      result = (FdmMesherComposite *)new FdmMesherComposite((ext::shared_ptr< Fdm1dMesher > const &)*arg1,(ext::shared_ptr< Fdm1dMesher > const &)*arg2,(ext::shared_ptr< Fdm1dMesher > 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 ? new ext::shared_ptr<  FdmMesherComposite >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmMesherComposite__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< Fdm1dMesher > *arg1 = 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg2 = 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg3 = 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg4 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempnull1 ;
  ext::shared_ptr< Fdm1dMesher > tempnull2 ;
  ext::shared_ptr< Fdm1dMesher > tempnull3 ;
  ext::shared_ptr< Fdm1dMesher > tempnull4 ;
  FdmMesherComposite *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Fdm1dMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Fdm1dMesher > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< Fdm1dMesher > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< Fdm1dMesher > *)jarg4 : &tempnull4; 
  {
    try {
      result = (FdmMesherComposite *)new FdmMesherComposite((ext::shared_ptr< Fdm1dMesher > const &)*arg1,(ext::shared_ptr< Fdm1dMesher > const &)*arg2,(ext::shared_ptr< Fdm1dMesher > const &)*arg3,(ext::shared_ptr< Fdm1dMesher > 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 ? new ext::shared_ptr<  FdmMesherComposite >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmMesherComposite_getFdm1dMeshers(void * jarg1) {
  void * jresult ;
  FdmMesherComposite *arg1 = (FdmMesherComposite *) 0 ;
  ext::shared_ptr< FdmMesherComposite const > *smartarg1 = 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const FdmMesherComposite > *)jarg1;
  arg1 = (FdmMesherComposite *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) &((FdmMesherComposite const *)arg1)->getFdm1dMeshers();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmMesherComposite(void * jarg1) {
  FdmMesherComposite *arg1 = (FdmMesherComposite *) 0 ;
  ext::shared_ptr< FdmMesherComposite > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmMesherComposite > *)jarg1;
  arg1 = (FdmMesherComposite *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOp_apply(void * jarg1, void * jarg2) {
  void * jresult ;
  FdmLinearOp *arg1 = (FdmLinearOp *) 0 ;
  Array *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOp const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmLinearOp > *)jarg1;
  arg1 = (FdmLinearOp *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((FdmLinearOp const *)arg1)->apply((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(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmLinearOp(void * jarg1) {
  FdmLinearOp *arg1 = (FdmLinearOp *) 0 ;
  ext::shared_ptr< FdmLinearOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmLinearOp > *)jarg1;
  arg1 = (FdmLinearOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SparseMatrix_row_idx_set(void * jarg1, void * jarg2) {
  SparseMatrix *arg1 = (SparseMatrix *) 0 ;
  std::vector< unsigned int > *arg2 = (std::vector< unsigned int > *) 0 ;
  ext::shared_ptr< SparseMatrix > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SparseMatrix > *)jarg1;
  arg1 = (SparseMatrix *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< unsigned int > *)jarg2; 
  if (arg1) (arg1)->row_idx = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SparseMatrix_row_idx_get(void * jarg1) {
  void * jresult ;
  SparseMatrix *arg1 = (SparseMatrix *) 0 ;
  ext::shared_ptr< SparseMatrix > *smartarg1 = 0 ;
  std::vector< unsigned int > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SparseMatrix > *)jarg1;
  arg1 = (SparseMatrix *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< unsigned int > *)& ((arg1)->row_idx);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SparseMatrix_col_idx_set(void * jarg1, void * jarg2) {
  SparseMatrix *arg1 = (SparseMatrix *) 0 ;
  std::vector< unsigned int > *arg2 = (std::vector< unsigned int > *) 0 ;
  ext::shared_ptr< SparseMatrix > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SparseMatrix > *)jarg1;
  arg1 = (SparseMatrix *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< unsigned int > *)jarg2; 
  if (arg1) (arg1)->col_idx = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SparseMatrix_col_idx_get(void * jarg1) {
  void * jresult ;
  SparseMatrix *arg1 = (SparseMatrix *) 0 ;
  ext::shared_ptr< SparseMatrix > *smartarg1 = 0 ;
  std::vector< unsigned int > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SparseMatrix > *)jarg1;
  arg1 = (SparseMatrix *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< unsigned int > *)& ((arg1)->col_idx);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_SparseMatrix_data_set(void * jarg1, void * jarg2) {
  SparseMatrix *arg1 = (SparseMatrix *) 0 ;
  std::vector< Real > *arg2 = (std::vector< Real > *) 0 ;
  ext::shared_ptr< SparseMatrix > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SparseMatrix > *)jarg1;
  arg1 = (SparseMatrix *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< Real > *)jarg2; 
  if (arg1) (arg1)->data = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_SparseMatrix_data_get(void * jarg1) {
  void * jresult ;
  SparseMatrix *arg1 = (SparseMatrix *) 0 ;
  ext::shared_ptr< SparseMatrix > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SparseMatrix > *)jarg1;
  arg1 = (SparseMatrix *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< Real > *)& ((arg1)->data);
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SparseMatrix(void * jarg1) {
  SparseMatrix *arg1 = (SparseMatrix *) 0 ;
  ext::shared_ptr< SparseMatrix > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SparseMatrix > *)jarg1;
  arg1 = (SparseMatrix *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_FdmLinearOpComposite_size(void * jarg1) {
  unsigned long jresult ;
  FdmLinearOpComposite *arg1 = (FdmLinearOpComposite *) 0 ;
  ext::shared_ptr< FdmLinearOpComposite const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmLinearOpComposite > *)jarg1;
  arg1 = (FdmLinearOpComposite *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((FdmLinearOpComposite 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_FdmLinearOpComposite_setTime(void * jarg1, double jarg2, double jarg3) {
  FdmLinearOpComposite *arg1 = (FdmLinearOpComposite *) 0 ;
  Time arg2 ;
  Time arg3 ;
  ext::shared_ptr< FdmLinearOpComposite > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmLinearOpComposite > *)jarg1;
  arg1 = (FdmLinearOpComposite *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      (arg1)->setTime(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_FdmLinearOpComposite_apply_mixed(void * jarg1, void * jarg2) {
  void * jresult ;
  FdmLinearOpComposite *arg1 = (FdmLinearOpComposite *) 0 ;
  Array *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmLinearOpComposite > *)jarg1;
  arg1 = (FdmLinearOpComposite *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((FdmLinearOpComposite const *)arg1)->apply_mixed((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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpComposite_apply_direction(void * jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  FdmLinearOpComposite *arg1 = (FdmLinearOpComposite *) 0 ;
  Size arg2 ;
  Array *arg3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmLinearOpComposite > *)jarg1;
  arg1 = (FdmLinearOpComposite *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((FdmLinearOpComposite const *)arg1)->apply_direction(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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpComposite_solve_splitting(void * jarg1, unsigned long jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  FdmLinearOpComposite *arg1 = (FdmLinearOpComposite *) 0 ;
  Size arg2 ;
  Array *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< FdmLinearOpComposite const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmLinearOpComposite > *)jarg1;
  arg1 = (FdmLinearOpComposite *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = ((FdmLinearOpComposite const *)arg1)->solve_splitting(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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpComposite_preconditioner(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  FdmLinearOpComposite *arg1 = (FdmLinearOpComposite *) 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< FdmLinearOpComposite const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmLinearOpComposite > *)jarg1;
  arg1 = (FdmLinearOpComposite *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = ((FdmLinearOpComposite const *)arg1)->preconditioner((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 = new Array(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpComposite_to_sparse_matrix(void * jarg1) {
  void * jresult ;
  FdmLinearOpComposite *arg1 = (FdmLinearOpComposite *) 0 ;
  ext::shared_ptr< FdmLinearOpComposite const > *smartarg1 = 0 ;
  ext::shared_ptr< SparseMatrix > result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmLinearOpComposite > *)jarg1;
  arg1 = (FdmLinearOpComposite *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = FdmLinearOpComposite_to_sparse_matrix((FdmLinearOpComposite const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< SparseMatrix >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmLinearOpComposite(void * jarg1) {
  FdmLinearOpComposite *arg1 = (FdmLinearOpComposite *) 0 ;
  ext::shared_ptr< FdmLinearOpComposite > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmLinearOpComposite > *)jarg1;
  arg1 = (FdmLinearOpComposite *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmLinearOpCompositeProxy(void * jarg1) {
  void * jresult ;
  FdmLinearOpCompositeDelegate *arg1 = (FdmLinearOpCompositeDelegate *) 0 ;
  FdmLinearOpCompositeProxy *result = 0 ;
  
  arg1 = (FdmLinearOpCompositeDelegate *)jarg1; 
  {
    try {
      result = (FdmLinearOpCompositeProxy *)new FdmLinearOpCompositeProxy(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdmLinearOpCompositeProxy >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmLinearOpCompositeProxy(void * jarg1) {
  FdmLinearOpCompositeProxy *arg1 = (FdmLinearOpCompositeProxy *) 0 ;
  ext::shared_ptr< FdmLinearOpCompositeProxy > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmLinearOpCompositeProxy > *)jarg1;
  arg1 = (FdmLinearOpCompositeProxy *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_FdmLinearOpCompositeDelegate(void * jarg1) {
  FdmLinearOpCompositeDelegate *arg1 = (FdmLinearOpCompositeDelegate *) 0 ;
  
  arg1 = (FdmLinearOpCompositeDelegate *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_FdmLinearOpCompositeDelegate_size(void * jarg1) {
  unsigned long jresult ;
  FdmLinearOpCompositeDelegate *arg1 = (FdmLinearOpCompositeDelegate *) 0 ;
  Size result;
  
  arg1 = (FdmLinearOpCompositeDelegate *)jarg1; 
  {
    try {
      result = ((FdmLinearOpCompositeDelegate 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_FdmLinearOpCompositeDelegate_sizeSwigExplicitFdmLinearOpCompositeDelegate(void * jarg1) {
  unsigned long jresult ;
  FdmLinearOpCompositeDelegate *arg1 = (FdmLinearOpCompositeDelegate *) 0 ;
  Size result;
  
  arg1 = (FdmLinearOpCompositeDelegate *)jarg1; 
  {
    try {
      result = ((FdmLinearOpCompositeDelegate const *)arg1)->FdmLinearOpCompositeDelegate::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_FdmLinearOpCompositeDelegate_setTime(void * jarg1, double jarg2, double jarg3) {
  FdmLinearOpCompositeDelegate *arg1 = (FdmLinearOpCompositeDelegate *) 0 ;
  Time arg2 ;
  Time arg3 ;
  
  arg1 = (FdmLinearOpCompositeDelegate *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      (arg1)->setTime(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_FdmLinearOpCompositeDelegate_setTimeSwigExplicitFdmLinearOpCompositeDelegate(void * jarg1, double jarg2, double jarg3) {
  FdmLinearOpCompositeDelegate *arg1 = (FdmLinearOpCompositeDelegate *) 0 ;
  Time arg2 ;
  Time arg3 ;
  
  arg1 = (FdmLinearOpCompositeDelegate *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      (arg1)->FdmLinearOpCompositeDelegate::setTime(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_FdmLinearOpCompositeDelegate_apply(void * jarg1, void * jarg2) {
  void * jresult ;
  FdmLinearOpCompositeDelegate *arg1 = (FdmLinearOpCompositeDelegate *) 0 ;
  Array *arg2 = 0 ;
  Array result;
  
  arg1 = (FdmLinearOpCompositeDelegate *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((FdmLinearOpCompositeDelegate const *)arg1)->apply((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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpCompositeDelegate_applySwigExplicitFdmLinearOpCompositeDelegate(void * jarg1, void * jarg2) {
  void * jresult ;
  FdmLinearOpCompositeDelegate *arg1 = (FdmLinearOpCompositeDelegate *) 0 ;
  Array *arg2 = 0 ;
  Array result;
  
  arg1 = (FdmLinearOpCompositeDelegate *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((FdmLinearOpCompositeDelegate const *)arg1)->FdmLinearOpCompositeDelegate::apply((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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpCompositeDelegate_apply_mixed(void * jarg1, void * jarg2) {
  void * jresult ;
  FdmLinearOpCompositeDelegate *arg1 = (FdmLinearOpCompositeDelegate *) 0 ;
  Array *arg2 = 0 ;
  Array result;
  
  arg1 = (FdmLinearOpCompositeDelegate *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((FdmLinearOpCompositeDelegate const *)arg1)->apply_mixed((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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpCompositeDelegate_apply_mixedSwigExplicitFdmLinearOpCompositeDelegate(void * jarg1, void * jarg2) {
  void * jresult ;
  FdmLinearOpCompositeDelegate *arg1 = (FdmLinearOpCompositeDelegate *) 0 ;
  Array *arg2 = 0 ;
  Array result;
  
  arg1 = (FdmLinearOpCompositeDelegate *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((FdmLinearOpCompositeDelegate const *)arg1)->FdmLinearOpCompositeDelegate::apply_mixed((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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpCompositeDelegate_apply_direction(void * jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  FdmLinearOpCompositeDelegate *arg1 = (FdmLinearOpCompositeDelegate *) 0 ;
  Size arg2 ;
  Array *arg3 = 0 ;
  Array result;
  
  arg1 = (FdmLinearOpCompositeDelegate *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((FdmLinearOpCompositeDelegate const *)arg1)->apply_direction(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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpCompositeDelegate_apply_directionSwigExplicitFdmLinearOpCompositeDelegate(void * jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  FdmLinearOpCompositeDelegate *arg1 = (FdmLinearOpCompositeDelegate *) 0 ;
  Size arg2 ;
  Array *arg3 = 0 ;
  Array result;
  
  arg1 = (FdmLinearOpCompositeDelegate *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((FdmLinearOpCompositeDelegate const *)arg1)->FdmLinearOpCompositeDelegate::apply_direction(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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpCompositeDelegate_solve_splitting(void * jarg1, unsigned long jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  FdmLinearOpCompositeDelegate *arg1 = (FdmLinearOpCompositeDelegate *) 0 ;
  Size arg2 ;
  Array *arg3 = 0 ;
  Real arg4 ;
  Array result;
  
  arg1 = (FdmLinearOpCompositeDelegate *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = ((FdmLinearOpCompositeDelegate const *)arg1)->solve_splitting(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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpCompositeDelegate_solve_splittingSwigExplicitFdmLinearOpCompositeDelegate(void * jarg1, unsigned long jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  FdmLinearOpCompositeDelegate *arg1 = (FdmLinearOpCompositeDelegate *) 0 ;
  Size arg2 ;
  Array *arg3 = 0 ;
  Real arg4 ;
  Array result;
  
  arg1 = (FdmLinearOpCompositeDelegate *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = ((FdmLinearOpCompositeDelegate const *)arg1)->FdmLinearOpCompositeDelegate::solve_splitting(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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpCompositeDelegate_preconditioner(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  FdmLinearOpCompositeDelegate *arg1 = (FdmLinearOpCompositeDelegate *) 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  Array result;
  
  arg1 = (FdmLinearOpCompositeDelegate *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = ((FdmLinearOpCompositeDelegate const *)arg1)->preconditioner((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 = new Array(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpCompositeDelegate_preconditionerSwigExplicitFdmLinearOpCompositeDelegate(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  FdmLinearOpCompositeDelegate *arg1 = (FdmLinearOpCompositeDelegate *) 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  Array result;
  
  arg1 = (FdmLinearOpCompositeDelegate *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = ((FdmLinearOpCompositeDelegate const *)arg1)->FdmLinearOpCompositeDelegate::preconditioner((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 = new Array(result); 
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FdmLinearOpCompositeDelegate_director_connect(void *objarg, SwigDirector_FdmLinearOpCompositeDelegate::SWIG_Callback0_t callback0, SwigDirector_FdmLinearOpCompositeDelegate::SWIG_Callback1_t callback1, SwigDirector_FdmLinearOpCompositeDelegate::SWIG_Callback2_t callback2, SwigDirector_FdmLinearOpCompositeDelegate::SWIG_Callback3_t callback3, SwigDirector_FdmLinearOpCompositeDelegate::SWIG_Callback4_t callback4, SwigDirector_FdmLinearOpCompositeDelegate::SWIG_Callback5_t callback5, SwigDirector_FdmLinearOpCompositeDelegate::SWIG_Callback6_t callback6) {
  FdmLinearOpCompositeDelegate *obj = (FdmLinearOpCompositeDelegate *)objarg;
  SwigDirector_FdmLinearOpCompositeDelegate *director = static_cast<SwigDirector_FdmLinearOpCompositeDelegate *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6);
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FdmBoundaryCondition_applyBeforeApplying(void * jarg1, void * jarg2) {
  FdmBoundaryCondition *arg1 = (FdmBoundaryCondition *) 0 ;
  FdmLinearOp *arg2 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition const > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const FdmBoundaryCondition > *)jarg1;
  arg1 = (FdmBoundaryCondition *)(smartarg1 ? smartarg1->get() : 0); 
  
  arg2 = (FdmLinearOp *)(((ext::shared_ptr<  FdmLinearOp > *)jarg2) ? ((ext::shared_ptr<  FdmLinearOp > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmLinearOp & reference is null", 0);
    return ;
  } 
  {
    try {
      ((FdmBoundaryCondition const *)arg1)->applyBeforeApplying(*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_FdmBoundaryCondition_applyAfterApplying(void * jarg1, void * jarg2) {
  FdmBoundaryCondition *arg1 = (FdmBoundaryCondition *) 0 ;
  Array *arg2 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition const > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const FdmBoundaryCondition > *)jarg1;
  arg1 = (FdmBoundaryCondition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & is null", 0);
    return ;
  } 
  {
    try {
      ((FdmBoundaryCondition const *)arg1)->applyAfterApplying(*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_FdmBoundaryCondition_applyBeforeSolving(void * jarg1, void * jarg2, void * jarg3) {
  FdmBoundaryCondition *arg1 = (FdmBoundaryCondition *) 0 ;
  FdmLinearOp *arg2 = 0 ;
  Array *arg3 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition const > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const FdmBoundaryCondition > *)jarg1;
  arg1 = (FdmBoundaryCondition *)(smartarg1 ? smartarg1->get() : 0); 
  
  arg2 = (FdmLinearOp *)(((ext::shared_ptr<  FdmLinearOp > *)jarg2) ? ((ext::shared_ptr<  FdmLinearOp > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmLinearOp & reference is null", 0);
    return ;
  } 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & is null", 0);
    return ;
  } 
  {
    try {
      ((FdmBoundaryCondition const *)arg1)->applyBeforeSolving(*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_FdmBoundaryCondition_applyAfterSolving(void * jarg1, void * jarg2) {
  FdmBoundaryCondition *arg1 = (FdmBoundaryCondition *) 0 ;
  Array *arg2 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition const > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const FdmBoundaryCondition > *)jarg1;
  arg1 = (FdmBoundaryCondition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & is null", 0);
    return ;
  } 
  {
    try {
      ((FdmBoundaryCondition const *)arg1)->applyAfterSolving(*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_FdmBoundaryCondition_setTime(void * jarg1, double jarg2) {
  FdmBoundaryCondition *arg1 = (FdmBoundaryCondition *) 0 ;
  Time arg2 ;
  ext::shared_ptr< FdmBoundaryCondition > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmBoundaryCondition > *)jarg1;
  arg1 = (FdmBoundaryCondition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      (arg1)->setTime(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_FdmBoundaryCondition(void * jarg1) {
  FdmBoundaryCondition *arg1 = (FdmBoundaryCondition *) 0 ;
  ext::shared_ptr< FdmBoundaryCondition > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmBoundaryCondition > *)jarg1;
  arg1 = (FdmBoundaryCondition *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FdmBoundaryConditionSet_Clear(void * jarg1) {
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)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_FdmBoundaryConditionSet_Add(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  ext::shared_ptr< FdmBoundaryCondition > *arg2 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmBoundaryCondition > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::shared_ptr< FdmBoundaryCondition > 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_FdmBoundaryConditionSet_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< FdmBoundaryCondition > > 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_FdmBoundaryConditionSet_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< FdmBoundaryCondition > > 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_FdmBoundaryConditionSet_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > >::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_FdmBoundaryConditionSet__SWIG_0() {
  void * jresult ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)new std::vector< ext::shared_ptr< FdmBoundaryCondition > >();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBoundaryConditionSet__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)new_std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_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_FdmBoundaryConditionSet_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< FdmBoundaryCondition > result;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_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 = result ? new ext::shared_ptr< FdmBoundaryCondition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmBoundaryConditionSet_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_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 = *result ? new std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FdmBoundaryConditionSet_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< FdmBoundaryCondition > *arg3 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmBoundaryCondition > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__setitem(arg1,arg2,(ext::shared_ptr< FdmBoundaryCondition > 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_FdmBoundaryConditionSet_AddRange(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< FdmBoundaryCondition > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__AddRange(arg1,(std::vector< ext::shared_ptr< FdmBoundaryCondition > > 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_FdmBoundaryConditionSet_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_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_FdmBoundaryConditionSet_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< FdmBoundaryCondition > *arg3 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmBoundaryCondition > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__Insert(arg1,arg2,(ext::shared_ptr< FdmBoundaryCondition > 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_FdmBoundaryConditionSet_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< FdmBoundaryCondition > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::shared_ptr< FdmBoundaryCondition > > 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_FdmBoundaryConditionSet_RemoveAt(void * jarg1, int jarg2) {
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_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_FdmBoundaryConditionSet_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_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_FdmBoundaryConditionSet_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< FdmBoundaryCondition > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< FdmBoundaryCondition > tempnull1 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmBoundaryCondition > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__Repeat((ext::shared_ptr< FdmBoundaryCondition > 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_FdmBoundaryConditionSet_Reverse__SWIG_0(void * jarg1) {
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_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_FdmBoundaryConditionSet_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_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_FdmBoundaryConditionSet_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< FdmBoundaryCondition > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::shared_ptr< FdmBoundaryCondition > > 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_FdmBoundaryConditionSet_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  ext::shared_ptr< FdmBoundaryCondition > *arg2 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmBoundaryCondition > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__Contains(arg1,(ext::shared_ptr< FdmBoundaryCondition > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_FdmBoundaryConditionSet_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  ext::shared_ptr< FdmBoundaryCondition > *arg2 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmBoundaryCondition > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__IndexOf(arg1,(ext::shared_ptr< FdmBoundaryCondition > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_FdmBoundaryConditionSet_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  ext::shared_ptr< FdmBoundaryCondition > *arg2 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmBoundaryCondition > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__LastIndexOf(arg1,(ext::shared_ptr< FdmBoundaryCondition > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_FdmBoundaryConditionSet_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  ext::shared_ptr< FdmBoundaryCondition > *arg2 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmBoundaryCondition > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__Remove(arg1,(ext::shared_ptr< FdmBoundaryCondition > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_FdmBoundaryConditionSet(void * jarg1) {
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmDirichletBoundary(void * jarg1, double jarg2, unsigned long jarg3, int jarg4) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  FdmDirichletBoundary::Side arg4 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  FdmDirichletBoundary *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (FdmDirichletBoundary::Side)jarg4; 
  {
    try {
      result = (FdmDirichletBoundary *)new FdmDirichletBoundary((ext::shared_ptr< FdmMesher > 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 ? new ext::shared_ptr<  FdmDirichletBoundary >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FdmDirichletBoundary_applyAfterApplying__SWIG_0(void * jarg1, void * jarg2) {
  FdmDirichletBoundary *arg1 = (FdmDirichletBoundary *) 0 ;
  Array *arg2 = 0 ;
  ext::shared_ptr< FdmDirichletBoundary const > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const FdmDirichletBoundary > *)jarg1;
  arg1 = (FdmDirichletBoundary *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & is null", 0);
    return ;
  } 
  {
    try {
      ((FdmDirichletBoundary const *)arg1)->applyAfterApplying(*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_FdmDirichletBoundary_applyAfterApplying__SWIG_1(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  FdmDirichletBoundary *arg1 = (FdmDirichletBoundary *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< FdmDirichletBoundary const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmDirichletBoundary > *)jarg1;
  arg1 = (FdmDirichletBoundary *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((FdmDirichletBoundary const *)arg1)->applyAfterApplying(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_FdmDirichletBoundary(void * jarg1) {
  FdmDirichletBoundary *arg1 = (FdmDirichletBoundary *) 0 ;
  ext::shared_ptr< FdmDirichletBoundary > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmDirichletBoundary > *)jarg1;
  arg1 = (FdmDirichletBoundary *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmDiscountDirichletBoundary(void * jarg1, void * jarg2, double jarg3, double jarg4, unsigned long jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Size arg5 ;
  FdmDiscountDirichletBoundary::Side arg6 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  FdmDiscountDirichletBoundary *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmDiscountDirichletBoundary::Side)jarg6; 
  {
    try {
      result = (FdmDiscountDirichletBoundary *)new FdmDiscountDirichletBoundary((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< YieldTermStructure > 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 ? new ext::shared_ptr<  FdmDiscountDirichletBoundary >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmDiscountDirichletBoundary(void * jarg1) {
  FdmDiscountDirichletBoundary *arg1 = (FdmDiscountDirichletBoundary *) 0 ;
  ext::shared_ptr< FdmDiscountDirichletBoundary > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmDiscountDirichletBoundary > *)jarg1;
  arg1 = (FdmDiscountDirichletBoundary *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmTimeDepDirichletBoundary(void * jarg1, void * jarg2, unsigned long jarg3, int jarg4) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Size arg3 ;
  FdmTimeDepDirichletBoundary::Side arg4 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  FdmTimeDepDirichletBoundary *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (FdmTimeDepDirichletBoundary::Side)jarg4; 
  {
    try {
      result = (FdmTimeDepDirichletBoundary *)new_FdmTimeDepDirichletBoundary((ext::shared_ptr< FdmMesher > const &)*arg1,arg2,SWIG_STD_MOVE(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 ? new ext::shared_ptr<  FdmTimeDepDirichletBoundary >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmTimeDepDirichletBoundary(void * jarg1) {
  FdmTimeDepDirichletBoundary *arg1 = (FdmTimeDepDirichletBoundary *) 0 ;
  ext::shared_ptr< FdmTimeDepDirichletBoundary > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmTimeDepDirichletBoundary > *)jarg1;
  arg1 = (FdmTimeDepDirichletBoundary *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBatesOp__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, void * jarg5) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< BatesProcess > *arg2 = 0 ;
  FdmBoundaryConditionSet *arg3 = 0 ;
  Size arg4 ;
  ext::shared_ptr< FdmQuantoHelper > *arg5 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< BatesProcess > tempnull2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull5 ;
  FdmBatesOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< BatesProcess > *)jarg2 : &tempnull2; 
  arg3 = (FdmBoundaryConditionSet *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmBoundaryConditionSet const & is null", 0);
    return 0;
  } 
  arg4 = (Size)jarg4; 
  arg5 = jarg5 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg5 : &tempnull5; 
  {
    try {
      result = (FdmBatesOp *)new FdmBatesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< BatesProcess > const &)*arg2,(FdmBoundaryConditionSet const &)*arg3,arg4,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdmBatesOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBatesOp__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< BatesProcess > *arg2 = 0 ;
  FdmBoundaryConditionSet *arg3 = 0 ;
  Size arg4 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< BatesProcess > tempnull2 ;
  FdmBatesOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< BatesProcess > *)jarg2 : &tempnull2; 
  arg3 = (FdmBoundaryConditionSet *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmBoundaryConditionSet const & is null", 0);
    return 0;
  } 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdmBatesOp *)new FdmBatesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< BatesProcess > const &)*arg2,(FdmBoundaryConditionSet 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 ? new ext::shared_ptr<  FdmBatesOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmBatesOp(void * jarg1) {
  FdmBatesOp *arg1 = (FdmBatesOp *) 0 ;
  ext::shared_ptr< FdmBatesOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmBatesOp > *)jarg1;
  arg1 = (FdmBatesOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesOp__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4, double jarg5, unsigned long jarg6, void * jarg7) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  doubleOrNull arg5 ;
  Size arg6 ;
  ext::shared_ptr< FdmQuantoHelper > *arg7 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull7 ;
  FdmBlackScholesOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = jarg7 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg7 : &tempnull7; 
  {
    try {
      result = (FdmBlackScholesOp *)new FdmBlackScholesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdmBlackScholesOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesOp__SWIG_1(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4, double jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  doubleOrNull arg5 ;
  Size arg6 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  FdmBlackScholesOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (doubleOrNull)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdmBlackScholesOp *)new FdmBlackScholesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdmBlackScholesOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesOp__SWIG_2(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4, double jarg5) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  doubleOrNull arg5 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  FdmBlackScholesOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (doubleOrNull)jarg5; 
  {
    try {
      result = (FdmBlackScholesOp *)new FdmBlackScholesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdmBlackScholesOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesOp__SWIG_3(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  FdmBlackScholesOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (FdmBlackScholesOp *)new FdmBlackScholesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdmBlackScholesOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesOp__SWIG_4(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  FdmBlackScholesOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (FdmBlackScholesOp *)new FdmBlackScholesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdmBlackScholesOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmBlackScholesOp(void * jarg1) {
  FdmBlackScholesOp *arg1 = (FdmBlackScholesOp *) 0 ;
  ext::shared_ptr< FdmBlackScholesOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmBlackScholesOp > *)jarg1;
  arg1 = (FdmBlackScholesOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fdm2dBlackScholesOp__SWIG_0(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5, unsigned int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Time arg5 ;
  bool arg6 ;
  doubleOrNull arg7 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Fdm2dBlackScholesOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Time)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = (doubleOrNull)jarg7; 
  {
    try {
      result = (Fdm2dBlackScholesOp *)new Fdm2dBlackScholesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  Fdm2dBlackScholesOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fdm2dBlackScholesOp__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5, unsigned int jarg6) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Time arg5 ;
  bool arg6 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Fdm2dBlackScholesOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Time)jarg5; 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (Fdm2dBlackScholesOp *)new Fdm2dBlackScholesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  Fdm2dBlackScholesOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fdm2dBlackScholesOp__SWIG_2(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Time arg5 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull3 ;
  Fdm2dBlackScholesOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  arg5 = (Time)jarg5; 
  {
    try {
      result = (Fdm2dBlackScholesOp *)new Fdm2dBlackScholesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  Fdm2dBlackScholesOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Fdm2dBlackScholesOp(void * jarg1) {
  Fdm2dBlackScholesOp *arg1 = (Fdm2dBlackScholesOp *) 0 ;
  ext::shared_ptr< Fdm2dBlackScholesOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Fdm2dBlackScholesOp > *)jarg1;
  arg1 = (Fdm2dBlackScholesOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmCEVOp(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Size arg6 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  FdmCEVOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdmCEVOp *)new FdmCEVOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< YieldTermStructure > 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 ? new ext::shared_ptr<  FdmCEVOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmCEVOp(void * jarg1) {
  FdmCEVOp *arg1 = (FdmCEVOp *) 0 ;
  ext::shared_ptr< FdmCEVOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmCEVOp > *)jarg1;
  arg1 = (FdmCEVOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmG2Op(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< G2 > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< G2 > tempnull2 ;
  FdmG2Op *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< G2 > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdmG2Op *)new FdmG2Op((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< G2 > 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 ? new ext::shared_ptr<  FdmG2Op >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmG2Op(void * jarg1) {
  FdmG2Op *arg1 = (FdmG2Op *) 0 ;
  ext::shared_ptr< FdmG2Op > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmG2Op > *)jarg1;
  arg1 = (FdmG2Op *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonHullWhiteOp(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  ext::shared_ptr< HullWhiteProcess > *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< HestonProcess > tempnull2 ;
  ext::shared_ptr< HullWhiteProcess > tempnull3 ;
  FdmHestonHullWhiteOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonProcess > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< HullWhiteProcess > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (FdmHestonHullWhiteOp *)new FdmHestonHullWhiteOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,(ext::shared_ptr< HullWhiteProcess > 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 ? new ext::shared_ptr<  FdmHestonHullWhiteOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmHestonHullWhiteOp(void * jarg1) {
  FdmHestonHullWhiteOp *arg1 = (FdmHestonHullWhiteOp *) 0 ;
  ext::shared_ptr< FdmHestonHullWhiteOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmHestonHullWhiteOp > *)jarg1;
  arg1 = (FdmHestonHullWhiteOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonOp__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg4 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< HestonProcess > tempnull2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull4 ;
  FdmHestonOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonProcess > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg4 : &tempnull4; 
  {
    try {
      result = (FdmHestonOp *)new FdmHestonOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdmHestonOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonOp__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< HestonProcess > tempnull2 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull3 ;
  FdmHestonOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonProcess > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg3 : &tempnull3; 
  {
    try {
      result = (FdmHestonOp *)new FdmHestonOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdmHestonOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonOp__SWIG_2(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< HestonProcess > tempnull2 ;
  FdmHestonOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonProcess > *)jarg2 : &tempnull2; 
  {
    try {
      result = (FdmHestonOp *)new FdmHestonOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< HestonProcess > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdmHestonOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmHestonOp(void * jarg1) {
  FdmHestonOp *arg1 = (FdmHestonOp *) 0 ;
  ext::shared_ptr< FdmHestonOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmHestonOp > *)jarg1;
  arg1 = (FdmHestonOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHullWhiteOp(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > *arg2 = 0 ;
  Size arg3 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< HullWhite > tempnull2 ;
  FdmHullWhiteOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HullWhite > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdmHullWhiteOp *)new FdmHullWhiteOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< HullWhite > 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 ? new ext::shared_ptr<  FdmHullWhiteOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmHullWhiteOp(void * jarg1) {
  FdmHullWhiteOp *arg1 = (FdmHullWhiteOp *) 0 ;
  ext::shared_ptr< FdmHullWhiteOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmHullWhiteOp > *)jarg1;
  arg1 = (FdmHullWhiteOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmLocalVolFwdOp__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< Quote > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg4 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg5 = 0 ;
  Size arg6 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< Quote > tempnull2 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  ext::shared_ptr< YieldTermStructure > tempnull4 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull5 ;
  FdmLocalVolFwdOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Quote > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< YieldTermStructure > *)jarg4 : &tempnull4; 
  arg5 = jarg5 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg5 : &tempnull5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdmLocalVolFwdOp *)new FdmLocalVolFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< Quote > const &)*arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(ext::shared_ptr< YieldTermStructure > const &)*arg4,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdmLocalVolFwdOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmLocalVolFwdOp__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< Quote > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg4 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg5 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< Quote > tempnull2 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  ext::shared_ptr< YieldTermStructure > tempnull4 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull5 ;
  FdmLocalVolFwdOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Quote > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< YieldTermStructure > *)jarg4 : &tempnull4; 
  arg5 = jarg5 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg5 : &tempnull5; 
  {
    try {
      result = (FdmLocalVolFwdOp *)new FdmLocalVolFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< Quote > const &)*arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(ext::shared_ptr< YieldTermStructure > const &)*arg4,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdmLocalVolFwdOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmLocalVolFwdOp(void * jarg1) {
  FdmLocalVolFwdOp *arg1 = (FdmLocalVolFwdOp *) 0 ;
  ext::shared_ptr< FdmLocalVolFwdOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmLocalVolFwdOp > *)jarg1;
  arg1 = (FdmLocalVolFwdOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmOrnsteinUhlenbeckOp__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  Size arg4 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempnull2 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  FdmOrnsteinUhlenbeckOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< OrnsteinUhlenbeckProcess > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdmOrnsteinUhlenbeckOp *)new FdmOrnsteinUhlenbeckOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg2,(ext::shared_ptr< 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 ? new ext::shared_ptr<  FdmOrnsteinUhlenbeckOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmOrnsteinUhlenbeckOp__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempnull2 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  FdmOrnsteinUhlenbeckOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< OrnsteinUhlenbeckProcess > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  {
    try {
      result = (FdmOrnsteinUhlenbeckOp *)new FdmOrnsteinUhlenbeckOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg2,(ext::shared_ptr< 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 = result ? new ext::shared_ptr<  FdmOrnsteinUhlenbeckOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmOrnsteinUhlenbeckOp(void * jarg1) {
  FdmOrnsteinUhlenbeckOp *arg1 = (FdmOrnsteinUhlenbeckOp *) 0 ;
  ext::shared_ptr< FdmOrnsteinUhlenbeckOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmOrnsteinUhlenbeckOp > *)jarg1;
  arg1 = (FdmOrnsteinUhlenbeckOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmSabrOp(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  FdmSabrOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (FdmSabrOp *)new FdmSabrOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< YieldTermStructure > 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 = result ? new ext::shared_ptr<  FdmSabrOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmSabrOp(void * jarg1) {
  FdmSabrOp *arg1 = (FdmSabrOp *) 0 ;
  ext::shared_ptr< FdmSabrOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmSabrOp > *)jarg1;
  arg1 = (FdmSabrOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmZabrOp(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  FdmZabrOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (FdmZabrOp *)new FdmZabrOp((ext::shared_ptr< FdmMesher > 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 ? new ext::shared_ptr<  FdmZabrOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmZabrOp(void * jarg1) {
  FdmZabrOp *arg1 = (FdmZabrOp *) 0 ;
  ext::shared_ptr< FdmZabrOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmZabrOp > *)jarg1;
  arg1 = (FdmZabrOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmDupire1dOp(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  Array *arg2 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  FdmDupire1dOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmDupire1dOp *)new FdmDupire1dOp((ext::shared_ptr< FdmMesher > 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 = result ? new ext::shared_ptr<  FdmDupire1dOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmDupire1dOp(void * jarg1) {
  FdmDupire1dOp *arg1 = (FdmDupire1dOp *) 0 ;
  ext::shared_ptr< FdmDupire1dOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmDupire1dOp > *)jarg1;
  arg1 = (FdmDupire1dOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesFwdOp__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4, double jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  Real arg5 ;
  Size arg6 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  FdmBlackScholesFwdOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdmBlackScholesFwdOp *)new FdmBlackScholesFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdmBlackScholesFwdOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesFwdOp__SWIG_1(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4, double jarg5) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  Real arg5 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  FdmBlackScholesFwdOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (FdmBlackScholesFwdOp *)new FdmBlackScholesFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdmBlackScholesFwdOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesFwdOp__SWIG_2(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  FdmBlackScholesFwdOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (FdmBlackScholesFwdOp *)new FdmBlackScholesFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdmBlackScholesFwdOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBlackScholesFwdOp__SWIG_3(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  FdmBlackScholesFwdOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (FdmBlackScholesFwdOp *)new FdmBlackScholesFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdmBlackScholesFwdOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmBlackScholesFwdOp(void * jarg1) {
  FdmBlackScholesFwdOp *arg1 = (FdmBlackScholesFwdOp *) 0 ;
  ext::shared_ptr< FdmBlackScholesFwdOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmBlackScholesFwdOp > *)jarg1;
  arg1 = (FdmBlackScholesFwdOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmSquareRootFwdOp__SWIG_0(void * jarg1, double jarg2, double jarg3, double jarg4, unsigned long jarg5, int jarg6) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Size arg5 ;
  FdmSquareRootFwdOp::TransformationType arg6 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  FdmSquareRootFwdOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (FdmSquareRootFwdOp::TransformationType)jarg6; 
  {
    try {
      result = (FdmSquareRootFwdOp *)new FdmSquareRootFwdOp((ext::shared_ptr< FdmMesher > 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 = result ? new ext::shared_ptr<  FdmSquareRootFwdOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmSquareRootFwdOp__SWIG_1(void * jarg1, double jarg2, double jarg3, double jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Size arg5 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  FdmSquareRootFwdOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdmSquareRootFwdOp *)new FdmSquareRootFwdOp((ext::shared_ptr< FdmMesher > 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 ? new ext::shared_ptr<  FdmSquareRootFwdOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmSquareRootFwdOp(void * jarg1) {
  FdmSquareRootFwdOp *arg1 = (FdmSquareRootFwdOp *) 0 ;
  ext::shared_ptr< FdmSquareRootFwdOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmSquareRootFwdOp > *)jarg1;
  arg1 = (FdmSquareRootFwdOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonFwdOp__SWIG_0(void * jarg1, void * jarg2, int jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  FdmSquareRootFwdOp::TransformationType arg3 ;
  ext::shared_ptr< LocalVolTermStructure > *arg4 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< HestonProcess > tempnull2 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull4 ;
  FdmHestonFwdOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonProcess > *)jarg2 : &tempnull2; 
  arg3 = (FdmSquareRootFwdOp::TransformationType)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg4 : &tempnull4; 
  {
    try {
      result = (FdmHestonFwdOp *)new FdmHestonFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,arg3,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdmHestonFwdOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonFwdOp__SWIG_1(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  FdmSquareRootFwdOp::TransformationType arg3 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< HestonProcess > tempnull2 ;
  FdmHestonFwdOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonProcess > *)jarg2 : &tempnull2; 
  arg3 = (FdmSquareRootFwdOp::TransformationType)jarg3; 
  {
    try {
      result = (FdmHestonFwdOp *)new FdmHestonFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  FdmHestonFwdOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonFwdOp__SWIG_2(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< HestonProcess > tempnull2 ;
  FdmHestonFwdOp *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonProcess > *)jarg2 : &tempnull2; 
  {
    try {
      result = (FdmHestonFwdOp *)new FdmHestonFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< HestonProcess > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdmHestonFwdOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmHestonFwdOp(void * jarg1) {
  FdmHestonFwdOp *arg1 = (FdmHestonFwdOp *) 0 ;
  ext::shared_ptr< FdmHestonFwdOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmHestonFwdOp > *)jarg1;
  arg1 = (FdmHestonFwdOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TripleBandLinearOp(unsigned long jarg1, void * jarg2) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull2 ;
  TripleBandLinearOp *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmMesher > *)jarg2 : &tempnull2; 
  {
    try {
      result = (TripleBandLinearOp *)new TripleBandLinearOp(arg1,(ext::shared_ptr< FdmMesher > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  TripleBandLinearOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_TripleBandLinearOp_apply(void * jarg1, void * jarg2) {
  void * jresult ;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  Array *arg2 = 0 ;
  ext::shared_ptr< TripleBandLinearOp const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const TripleBandLinearOp > *)jarg1;
  arg1 = (TripleBandLinearOp *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((TripleBandLinearOp const *)arg1)->apply((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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_TripleBandLinearOp_solve_splitting__SWIG_0(void * jarg1, void * jarg2, double jarg3, double jarg4) {
  void * jresult ;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  ext::shared_ptr< TripleBandLinearOp const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const TripleBandLinearOp > *)jarg1;
  arg1 = (TripleBandLinearOp *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = ((TripleBandLinearOp const *)arg1)->solve_splitting((Array 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 Array(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_TripleBandLinearOp_solve_splitting__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< TripleBandLinearOp const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const TripleBandLinearOp > *)jarg1;
  arg1 = (TripleBandLinearOp *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = ((TripleBandLinearOp const *)arg1)->solve_splitting((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 = new Array(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_TripleBandLinearOp_mult(void * jarg1, void * jarg2) {
  void * jresult ;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  Array *arg2 = 0 ;
  ext::shared_ptr< TripleBandLinearOp const > *smartarg1 = 0 ;
  SwigValueWrapper< TripleBandLinearOp > result;
  
  
  smartarg1 = (ext::shared_ptr< const TripleBandLinearOp > *)jarg1;
  arg1 = (TripleBandLinearOp *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((TripleBandLinearOp const *)arg1)->mult((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 ext::shared_ptr<  TripleBandLinearOp >(new TripleBandLinearOp(result)); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_TripleBandLinearOp_multR(void * jarg1, void * jarg2) {
  void * jresult ;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  Array *arg2 = 0 ;
  ext::shared_ptr< TripleBandLinearOp const > *smartarg1 = 0 ;
  SwigValueWrapper< TripleBandLinearOp > result;
  
  
  smartarg1 = (ext::shared_ptr< const TripleBandLinearOp > *)jarg1;
  arg1 = (TripleBandLinearOp *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((TripleBandLinearOp const *)arg1)->multR((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 ext::shared_ptr<  TripleBandLinearOp >(new TripleBandLinearOp(result)); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_TripleBandLinearOp_add__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  TripleBandLinearOp *arg2 = 0 ;
  ext::shared_ptr< TripleBandLinearOp const > *smartarg1 = 0 ;
  SwigValueWrapper< TripleBandLinearOp > result;
  
  
  smartarg1 = (ext::shared_ptr< const TripleBandLinearOp > *)jarg1;
  arg1 = (TripleBandLinearOp *)(smartarg1 ? smartarg1->get() : 0); 
  
  arg2 = (TripleBandLinearOp *)(((ext::shared_ptr< const TripleBandLinearOp > *)jarg2) ? ((ext::shared_ptr< const TripleBandLinearOp > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TripleBandLinearOp const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = ((TripleBandLinearOp const *)arg1)->add((TripleBandLinearOp const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new ext::shared_ptr<  TripleBandLinearOp >(new TripleBandLinearOp(result)); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_TripleBandLinearOp_add__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  Array *arg2 = 0 ;
  ext::shared_ptr< TripleBandLinearOp const > *smartarg1 = 0 ;
  SwigValueWrapper< TripleBandLinearOp > result;
  
  
  smartarg1 = (ext::shared_ptr< const TripleBandLinearOp > *)jarg1;
  arg1 = (TripleBandLinearOp *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((TripleBandLinearOp const *)arg1)->add((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 ext::shared_ptr<  TripleBandLinearOp >(new TripleBandLinearOp(result)); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_TripleBandLinearOp_axpyb(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  Array *arg2 = 0 ;
  TripleBandLinearOp *arg3 = 0 ;
  TripleBandLinearOp *arg4 = 0 ;
  Array *arg5 = 0 ;
  ext::shared_ptr< TripleBandLinearOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  TripleBandLinearOp > *)jarg1;
  arg1 = (TripleBandLinearOp *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return ;
  } 
  
  arg3 = (TripleBandLinearOp *)(((ext::shared_ptr< const TripleBandLinearOp > *)jarg3) ? ((ext::shared_ptr< const TripleBandLinearOp > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TripleBandLinearOp const & reference is null", 0);
    return ;
  } 
  
  arg4 = (TripleBandLinearOp *)(((ext::shared_ptr< const TripleBandLinearOp > *)jarg4) ? ((ext::shared_ptr< const TripleBandLinearOp > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TripleBandLinearOp const & reference is null", 0);
    return ;
  } 
  arg5 = (Array *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->axpyb((Array const &)*arg2,(TripleBandLinearOp const &)*arg3,(TripleBandLinearOp const &)*arg4,(Array 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_TripleBandLinearOp_swap(void * jarg1, void * jarg2) {
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  TripleBandLinearOp *arg2 = 0 ;
  ext::shared_ptr< TripleBandLinearOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  TripleBandLinearOp > *)jarg1;
  arg1 = (TripleBandLinearOp *)(smartarg1 ? smartarg1->get() : 0); 
  
  arg2 = (TripleBandLinearOp *)(((ext::shared_ptr<  TripleBandLinearOp > *)jarg2) ? ((ext::shared_ptr<  TripleBandLinearOp > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TripleBandLinearOp & reference 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_delete_TripleBandLinearOp(void * jarg1) {
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  ext::shared_ptr< TripleBandLinearOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  TripleBandLinearOp > *)jarg1;
  arg1 = (TripleBandLinearOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FirstDerivativeOp(unsigned long jarg1, void * jarg2) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull2 ;
  FirstDerivativeOp *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmMesher > *)jarg2 : &tempnull2; 
  {
    try {
      result = (FirstDerivativeOp *)new FirstDerivativeOp(arg1,(ext::shared_ptr< FdmMesher > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FirstDerivativeOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FirstDerivativeOp(void * jarg1) {
  FirstDerivativeOp *arg1 = (FirstDerivativeOp *) 0 ;
  ext::shared_ptr< FirstDerivativeOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FirstDerivativeOp > *)jarg1;
  arg1 = (FirstDerivativeOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SecondDerivativeOp(unsigned long jarg1, void * jarg2) {
  void * jresult ;
  Size arg1 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull2 ;
  SecondDerivativeOp *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmMesher > *)jarg2 : &tempnull2; 
  {
    try {
      result = (SecondDerivativeOp *)new SecondDerivativeOp(arg1,(ext::shared_ptr< FdmMesher > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  SecondDerivativeOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SecondDerivativeOp(void * jarg1) {
  SecondDerivativeOp *arg1 = (SecondDerivativeOp *) 0 ;
  ext::shared_ptr< SecondDerivativeOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SecondDerivativeOp > *)jarg1;
  arg1 = (SecondDerivativeOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NinePointLinearOp(unsigned long jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  ext::shared_ptr< FdmMesher > *arg3 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull3 ;
  NinePointLinearOp *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmMesher > *)jarg3 : &tempnull3; 
  {
    try {
      result = (NinePointLinearOp *)new NinePointLinearOp(arg1,arg2,(ext::shared_ptr< FdmMesher > 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 ? new ext::shared_ptr<  NinePointLinearOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NinePointLinearOp(void * jarg1) {
  NinePointLinearOp *arg1 = (NinePointLinearOp *) 0 ;
  ext::shared_ptr< NinePointLinearOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  NinePointLinearOp > *)jarg1;
  arg1 = (NinePointLinearOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SecondOrderMixedDerivativeOp(unsigned long jarg1, unsigned long jarg2, void * jarg3) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  ext::shared_ptr< FdmMesher > *arg3 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull3 ;
  SecondOrderMixedDerivativeOp *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmMesher > *)jarg3 : &tempnull3; 
  {
    try {
      result = (SecondOrderMixedDerivativeOp *)new SecondOrderMixedDerivativeOp(arg1,arg2,(ext::shared_ptr< FdmMesher > 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 ? new ext::shared_ptr<  SecondOrderMixedDerivativeOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SecondOrderMixedDerivativeOp(void * jarg1) {
  SecondOrderMixedDerivativeOp *arg1 = (SecondOrderMixedDerivativeOp *) 0 ;
  ext::shared_ptr< SecondOrderMixedDerivativeOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SecondOrderMixedDerivativeOp > *)jarg1;
  arg1 = (SecondOrderMixedDerivativeOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NthOrderDerivativeOp(unsigned long jarg1, unsigned long jarg2, int jarg3, void * jarg4) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  Integer arg3 ;
  ext::shared_ptr< FdmMesher > *arg4 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull4 ;
  NthOrderDerivativeOp *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Integer)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< FdmMesher > *)jarg4 : &tempnull4; 
  {
    try {
      result = (NthOrderDerivativeOp *)new NthOrderDerivativeOp(arg1,arg2,arg3,(ext::shared_ptr< FdmMesher > 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 ? new ext::shared_ptr<  NthOrderDerivativeOp >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NthOrderDerivativeOp(void * jarg1) {
  NthOrderDerivativeOp *arg1 = (NthOrderDerivativeOp *) 0 ;
  ext::shared_ptr< NthOrderDerivativeOp > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  NthOrderDerivativeOp > *)jarg1;
  arg1 = (NthOrderDerivativeOp *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CraigSneydScheme__SWIG_0(double jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  FdmBoundaryConditionSet *arg4 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull3 ;
  CraigSneydScheme *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg3 : &tempnull3; 
  arg4 = (FdmBoundaryConditionSet *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmBoundaryConditionSet const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CraigSneydScheme *)new CraigSneydScheme(arg1,arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3,(FdmBoundaryConditionSet 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 ? new ext::shared_ptr<  CraigSneydScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CraigSneydScheme__SWIG_1(double jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull3 ;
  CraigSneydScheme *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg3 : &tempnull3; 
  {
    try {
      result = (CraigSneydScheme *)new CraigSneydScheme(arg1,arg2,(ext::shared_ptr< FdmLinearOpComposite > 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 ? new ext::shared_ptr<  CraigSneydScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CraigSneydScheme_step(void * jarg1, void * jarg2, double jarg3) {
  CraigSneydScheme *arg1 = (CraigSneydScheme *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< CraigSneydScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CraigSneydScheme > *)jarg1;
  arg1 = (CraigSneydScheme *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & is null", 0);
    return ;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      (arg1)->step(*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_CraigSneydScheme_setStep(void * jarg1, double jarg2) {
  CraigSneydScheme *arg1 = (CraigSneydScheme *) 0 ;
  Time arg2 ;
  ext::shared_ptr< CraigSneydScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CraigSneydScheme > *)jarg1;
  arg1 = (CraigSneydScheme *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      (arg1)->setStep(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_CraigSneydScheme(void * jarg1) {
  CraigSneydScheme *arg1 = (CraigSneydScheme *) 0 ;
  ext::shared_ptr< CraigSneydScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CraigSneydScheme > *)jarg1;
  arg1 = (CraigSneydScheme *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ImplicitEulerScheme__SWIG_0(void * jarg1, void * jarg2, double jarg3, int jarg4) {
  void * jresult ;
  ext::shared_ptr< FdmLinearOpComposite > *arg1 = 0 ;
  FdmBoundaryConditionSet *arg2 = 0 ;
  Real arg3 ;
  ImplicitEulerScheme::SolverType arg4 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull1 ;
  ImplicitEulerScheme *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg1 : &tempnull1; 
  arg2 = (FdmBoundaryConditionSet *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmBoundaryConditionSet const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (ImplicitEulerScheme::SolverType)jarg4; 
  {
    try {
      result = (ImplicitEulerScheme *)new ImplicitEulerScheme((ext::shared_ptr< FdmLinearOpComposite > const &)*arg1,(FdmBoundaryConditionSet 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 ? new ext::shared_ptr<  ImplicitEulerScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ImplicitEulerScheme__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< FdmLinearOpComposite > *arg1 = 0 ;
  FdmBoundaryConditionSet *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull1 ;
  ImplicitEulerScheme *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg1 : &tempnull1; 
  arg2 = (FdmBoundaryConditionSet *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmBoundaryConditionSet const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (ImplicitEulerScheme *)new ImplicitEulerScheme((ext::shared_ptr< FdmLinearOpComposite > const &)*arg1,(FdmBoundaryConditionSet 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 ? new ext::shared_ptr<  ImplicitEulerScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ImplicitEulerScheme__SWIG_2(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< FdmLinearOpComposite > *arg1 = 0 ;
  FdmBoundaryConditionSet *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull1 ;
  ImplicitEulerScheme *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg1 : &tempnull1; 
  arg2 = (FdmBoundaryConditionSet *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmBoundaryConditionSet const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ImplicitEulerScheme *)new ImplicitEulerScheme((ext::shared_ptr< FdmLinearOpComposite > const &)*arg1,(FdmBoundaryConditionSet const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  ImplicitEulerScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ImplicitEulerScheme__SWIG_3(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< FdmLinearOpComposite > *arg1 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull1 ;
  ImplicitEulerScheme *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg1 : &tempnull1; 
  {
    try {
      result = (ImplicitEulerScheme *)new ImplicitEulerScheme((ext::shared_ptr< FdmLinearOpComposite > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  ImplicitEulerScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ImplicitEulerScheme_step(void * jarg1, void * jarg2, double jarg3) {
  ImplicitEulerScheme *arg1 = (ImplicitEulerScheme *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< ImplicitEulerScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ImplicitEulerScheme > *)jarg1;
  arg1 = (ImplicitEulerScheme *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & is null", 0);
    return ;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      (arg1)->step(*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_ImplicitEulerScheme_setStep(void * jarg1, double jarg2) {
  ImplicitEulerScheme *arg1 = (ImplicitEulerScheme *) 0 ;
  Time arg2 ;
  ext::shared_ptr< ImplicitEulerScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ImplicitEulerScheme > *)jarg1;
  arg1 = (ImplicitEulerScheme *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      (arg1)->setStep(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_ImplicitEulerScheme_numberOfIterations(void * jarg1) {
  unsigned long jresult ;
  ImplicitEulerScheme *arg1 = (ImplicitEulerScheme *) 0 ;
  ext::shared_ptr< ImplicitEulerScheme const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const ImplicitEulerScheme > *)jarg1;
  arg1 = (ImplicitEulerScheme *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((ImplicitEulerScheme 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 = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ImplicitEulerScheme(void * jarg1) {
  ImplicitEulerScheme *arg1 = (ImplicitEulerScheme *) 0 ;
  ext::shared_ptr< ImplicitEulerScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ImplicitEulerScheme > *)jarg1;
  arg1 = (ImplicitEulerScheme *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CrankNicolsonScheme__SWIG_0(double jarg1, void * jarg2, void * jarg3, double jarg4, int jarg5) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg2 = 0 ;
  FdmBoundaryConditionSet *arg3 = 0 ;
  Real arg4 ;
  ImplicitEulerScheme::SolverType arg5 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull2 ;
  CrankNicolsonScheme *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg2 : &tempnull2; 
  arg3 = (FdmBoundaryConditionSet *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmBoundaryConditionSet const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (ImplicitEulerScheme::SolverType)jarg5; 
  {
    try {
      result = (CrankNicolsonScheme *)new CrankNicolsonScheme(arg1,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg2,(FdmBoundaryConditionSet 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 ? new ext::shared_ptr<  CrankNicolsonScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CrankNicolsonScheme__SWIG_1(double jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg2 = 0 ;
  FdmBoundaryConditionSet *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull2 ;
  CrankNicolsonScheme *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg2 : &tempnull2; 
  arg3 = (FdmBoundaryConditionSet *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmBoundaryConditionSet const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (CrankNicolsonScheme *)new CrankNicolsonScheme(arg1,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg2,(FdmBoundaryConditionSet 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 ? new ext::shared_ptr<  CrankNicolsonScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CrankNicolsonScheme__SWIG_2(double jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg2 = 0 ;
  FdmBoundaryConditionSet *arg3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull2 ;
  CrankNicolsonScheme *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg2 : &tempnull2; 
  arg3 = (FdmBoundaryConditionSet *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmBoundaryConditionSet const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CrankNicolsonScheme *)new CrankNicolsonScheme(arg1,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg2,(FdmBoundaryConditionSet 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 ? new ext::shared_ptr<  CrankNicolsonScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CrankNicolsonScheme__SWIG_3(double jarg1, void * jarg2) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull2 ;
  CrankNicolsonScheme *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg2 : &tempnull2; 
  {
    try {
      result = (CrankNicolsonScheme *)new CrankNicolsonScheme(arg1,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  CrankNicolsonScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_CrankNicolsonScheme_step(void * jarg1, void * jarg2, double jarg3) {
  CrankNicolsonScheme *arg1 = (CrankNicolsonScheme *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< CrankNicolsonScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CrankNicolsonScheme > *)jarg1;
  arg1 = (CrankNicolsonScheme *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & is null", 0);
    return ;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      (arg1)->step(*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_CrankNicolsonScheme_setStep(void * jarg1, double jarg2) {
  CrankNicolsonScheme *arg1 = (CrankNicolsonScheme *) 0 ;
  Time arg2 ;
  ext::shared_ptr< CrankNicolsonScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CrankNicolsonScheme > *)jarg1;
  arg1 = (CrankNicolsonScheme *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      (arg1)->setStep(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_CrankNicolsonScheme_numberOfIterations(void * jarg1) {
  unsigned long jresult ;
  CrankNicolsonScheme *arg1 = (CrankNicolsonScheme *) 0 ;
  ext::shared_ptr< CrankNicolsonScheme const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const CrankNicolsonScheme > *)jarg1;
  arg1 = (CrankNicolsonScheme *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((CrankNicolsonScheme 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 = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CrankNicolsonScheme(void * jarg1) {
  CrankNicolsonScheme *arg1 = (CrankNicolsonScheme *) 0 ;
  ext::shared_ptr< CrankNicolsonScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CrankNicolsonScheme > *)jarg1;
  arg1 = (CrankNicolsonScheme *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DouglasScheme__SWIG_0(double jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg2 = 0 ;
  FdmBoundaryConditionSet *arg3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull2 ;
  DouglasScheme *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg2 : &tempnull2; 
  arg3 = (FdmBoundaryConditionSet *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmBoundaryConditionSet const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (DouglasScheme *)new DouglasScheme(arg1,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg2,(FdmBoundaryConditionSet 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 ? new ext::shared_ptr<  DouglasScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_DouglasScheme__SWIG_1(double jarg1, void * jarg2) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull2 ;
  DouglasScheme *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg2 : &tempnull2; 
  {
    try {
      result = (DouglasScheme *)new DouglasScheme(arg1,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  DouglasScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_DouglasScheme_step(void * jarg1, void * jarg2, double jarg3) {
  DouglasScheme *arg1 = (DouglasScheme *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< DouglasScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DouglasScheme > *)jarg1;
  arg1 = (DouglasScheme *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & is null", 0);
    return ;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      (arg1)->step(*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_DouglasScheme_setStep(void * jarg1, double jarg2) {
  DouglasScheme *arg1 = (DouglasScheme *) 0 ;
  Time arg2 ;
  ext::shared_ptr< DouglasScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DouglasScheme > *)jarg1;
  arg1 = (DouglasScheme *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      (arg1)->setStep(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_DouglasScheme(void * jarg1) {
  DouglasScheme *arg1 = (DouglasScheme *) 0 ;
  ext::shared_ptr< DouglasScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DouglasScheme > *)jarg1;
  arg1 = (DouglasScheme *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExplicitEulerScheme__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< FdmLinearOpComposite > *arg1 = 0 ;
  FdmBoundaryConditionSet *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull1 ;
  ExplicitEulerScheme *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg1 : &tempnull1; 
  arg2 = (FdmBoundaryConditionSet *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmBoundaryConditionSet const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ExplicitEulerScheme *)new ExplicitEulerScheme((ext::shared_ptr< FdmLinearOpComposite > const &)*arg1,(FdmBoundaryConditionSet const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  ExplicitEulerScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExplicitEulerScheme__SWIG_1(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< FdmLinearOpComposite > *arg1 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull1 ;
  ExplicitEulerScheme *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg1 : &tempnull1; 
  {
    try {
      result = (ExplicitEulerScheme *)new ExplicitEulerScheme((ext::shared_ptr< FdmLinearOpComposite > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  ExplicitEulerScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ExplicitEulerScheme_step(void * jarg1, void * jarg2, double jarg3) {
  ExplicitEulerScheme *arg1 = (ExplicitEulerScheme *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< ExplicitEulerScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ExplicitEulerScheme > *)jarg1;
  arg1 = (ExplicitEulerScheme *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & is null", 0);
    return ;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      (arg1)->step(*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_ExplicitEulerScheme_setStep(void * jarg1, double jarg2) {
  ExplicitEulerScheme *arg1 = (ExplicitEulerScheme *) 0 ;
  Time arg2 ;
  ext::shared_ptr< ExplicitEulerScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ExplicitEulerScheme > *)jarg1;
  arg1 = (ExplicitEulerScheme *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      (arg1)->setStep(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_ExplicitEulerScheme(void * jarg1) {
  ExplicitEulerScheme *arg1 = (ExplicitEulerScheme *) 0 ;
  ext::shared_ptr< ExplicitEulerScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ExplicitEulerScheme > *)jarg1;
  arg1 = (ExplicitEulerScheme *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HundsdorferScheme__SWIG_0(double jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  FdmBoundaryConditionSet *arg4 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull3 ;
  HundsdorferScheme *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg3 : &tempnull3; 
  arg4 = (FdmBoundaryConditionSet *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmBoundaryConditionSet const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (HundsdorferScheme *)new HundsdorferScheme(arg1,arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3,(FdmBoundaryConditionSet 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 ? new ext::shared_ptr<  HundsdorferScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HundsdorferScheme__SWIG_1(double jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull3 ;
  HundsdorferScheme *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg3 : &tempnull3; 
  {
    try {
      result = (HundsdorferScheme *)new HundsdorferScheme(arg1,arg2,(ext::shared_ptr< FdmLinearOpComposite > 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 ? new ext::shared_ptr<  HundsdorferScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_HundsdorferScheme_step(void * jarg1, void * jarg2, double jarg3) {
  HundsdorferScheme *arg1 = (HundsdorferScheme *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< HundsdorferScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  HundsdorferScheme > *)jarg1;
  arg1 = (HundsdorferScheme *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & is null", 0);
    return ;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      (arg1)->step(*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_HundsdorferScheme_setStep(void * jarg1, double jarg2) {
  HundsdorferScheme *arg1 = (HundsdorferScheme *) 0 ;
  Time arg2 ;
  ext::shared_ptr< HundsdorferScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  HundsdorferScheme > *)jarg1;
  arg1 = (HundsdorferScheme *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      (arg1)->setStep(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_HundsdorferScheme(void * jarg1) {
  HundsdorferScheme *arg1 = (HundsdorferScheme *) 0 ;
  ext::shared_ptr< HundsdorferScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  HundsdorferScheme > *)jarg1;
  arg1 = (HundsdorferScheme *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MethodOfLinesScheme__SWIG_0(double jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  FdmBoundaryConditionSet *arg4 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull3 ;
  MethodOfLinesScheme *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg3 : &tempnull3; 
  arg4 = (FdmBoundaryConditionSet *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmBoundaryConditionSet const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MethodOfLinesScheme *)new MethodOfLinesScheme(arg1,arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3,(FdmBoundaryConditionSet 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 ? new ext::shared_ptr<  MethodOfLinesScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MethodOfLinesScheme__SWIG_1(double jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull3 ;
  MethodOfLinesScheme *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg3 : &tempnull3; 
  {
    try {
      result = (MethodOfLinesScheme *)new MethodOfLinesScheme(arg1,arg2,(ext::shared_ptr< FdmLinearOpComposite > 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 ? new ext::shared_ptr<  MethodOfLinesScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MethodOfLinesScheme_step(void * jarg1, void * jarg2, double jarg3) {
  MethodOfLinesScheme *arg1 = (MethodOfLinesScheme *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< MethodOfLinesScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MethodOfLinesScheme > *)jarg1;
  arg1 = (MethodOfLinesScheme *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & is null", 0);
    return ;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      (arg1)->step(*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_MethodOfLinesScheme_setStep(void * jarg1, double jarg2) {
  MethodOfLinesScheme *arg1 = (MethodOfLinesScheme *) 0 ;
  Time arg2 ;
  ext::shared_ptr< MethodOfLinesScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MethodOfLinesScheme > *)jarg1;
  arg1 = (MethodOfLinesScheme *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      (arg1)->setStep(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_MethodOfLinesScheme(void * jarg1) {
  MethodOfLinesScheme *arg1 = (MethodOfLinesScheme *) 0 ;
  ext::shared_ptr< MethodOfLinesScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MethodOfLinesScheme > *)jarg1;
  arg1 = (MethodOfLinesScheme *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ModifiedCraigSneydScheme__SWIG_0(double jarg1, double jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  FdmBoundaryConditionSet *arg4 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull3 ;
  ModifiedCraigSneydScheme *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg3 : &tempnull3; 
  arg4 = (FdmBoundaryConditionSet *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmBoundaryConditionSet const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ModifiedCraigSneydScheme *)new ModifiedCraigSneydScheme(arg1,arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3,(FdmBoundaryConditionSet 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 ? new ext::shared_ptr<  ModifiedCraigSneydScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ModifiedCraigSneydScheme__SWIG_1(double jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull3 ;
  ModifiedCraigSneydScheme *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg3 : &tempnull3; 
  {
    try {
      result = (ModifiedCraigSneydScheme *)new ModifiedCraigSneydScheme(arg1,arg2,(ext::shared_ptr< FdmLinearOpComposite > 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 ? new ext::shared_ptr<  ModifiedCraigSneydScheme >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_ModifiedCraigSneydScheme_step(void * jarg1, void * jarg2, double jarg3) {
  ModifiedCraigSneydScheme *arg1 = (ModifiedCraigSneydScheme *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< ModifiedCraigSneydScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ModifiedCraigSneydScheme > *)jarg1;
  arg1 = (ModifiedCraigSneydScheme *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & is null", 0);
    return ;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      (arg1)->step(*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_ModifiedCraigSneydScheme_setStep(void * jarg1, double jarg2) {
  ModifiedCraigSneydScheme *arg1 = (ModifiedCraigSneydScheme *) 0 ;
  Time arg2 ;
  ext::shared_ptr< ModifiedCraigSneydScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ModifiedCraigSneydScheme > *)jarg1;
  arg1 = (ModifiedCraigSneydScheme *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      (arg1)->setStep(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_ModifiedCraigSneydScheme(void * jarg1) {
  ModifiedCraigSneydScheme *arg1 = (ModifiedCraigSneydScheme *) 0 ;
  ext::shared_ptr< ModifiedCraigSneydScheme > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ModifiedCraigSneydScheme > *)jarg1;
  arg1 = (ModifiedCraigSneydScheme *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FdmStepCondition_applyTo(void * jarg1, void * jarg2, double jarg3) {
  StepCondition< Array > *arg1 = (StepCondition< Array > *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< StepCondition< Array > const > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const StepCondition<Array> > *)jarg1;
  arg1 = (StepCondition<Array> *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & is null", 0);
    return ;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      ((StepCondition< Array > const *)arg1)->applyTo(*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_FdmStepCondition(void * jarg1) {
  StepCondition< Array > *arg1 = (StepCondition< Array > *) 0 ;
  ext::shared_ptr< StepCondition< Array > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  StepCondition<Array> > *)jarg1;
  arg1 = (StepCondition<Array> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmStepConditionProxy(void * jarg1) {
  void * jresult ;
  FdmStepConditionDelegate *arg1 = (FdmStepConditionDelegate *) 0 ;
  FdmStepConditionProxy *result = 0 ;
  
  arg1 = (FdmStepConditionDelegate *)jarg1; 
  {
    try {
      result = (FdmStepConditionProxy *)new FdmStepConditionProxy(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdmStepConditionProxy >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmStepConditionProxy(void * jarg1) {
  FdmStepConditionProxy *arg1 = (FdmStepConditionProxy *) 0 ;
  ext::shared_ptr< FdmStepConditionProxy > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmStepConditionProxy > *)jarg1;
  arg1 = (FdmStepConditionProxy *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_FdmStepConditionDelegate(void * jarg1) {
  FdmStepConditionDelegate *arg1 = (FdmStepConditionDelegate *) 0 ;
  
  arg1 = (FdmStepConditionDelegate *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FdmStepConditionDelegate_applyTo(void * jarg1, void * jarg2, double jarg3) {
  FdmStepConditionDelegate *arg1 = (FdmStepConditionDelegate *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  
  arg1 = (FdmStepConditionDelegate *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & is null", 0);
    return ;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      ((FdmStepConditionDelegate const *)arg1)->applyTo(*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_FdmStepConditionDelegate_applyToSwigExplicitFdmStepConditionDelegate(void * jarg1, void * jarg2, double jarg3) {
  FdmStepConditionDelegate *arg1 = (FdmStepConditionDelegate *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  
  arg1 = (FdmStepConditionDelegate *)jarg1; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & is null", 0);
    return ;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      ((FdmStepConditionDelegate const *)arg1)->FdmStepConditionDelegate::applyTo(*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_new_FdmStepConditionDelegate() {
  void * jresult ;
  FdmStepConditionDelegate *result = 0 ;
  
  {
    try {
      result = (FdmStepConditionDelegate *)new SwigDirector_FdmStepConditionDelegate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FdmStepConditionDelegate_director_connect(void *objarg, SwigDirector_FdmStepConditionDelegate::SWIG_Callback0_t callback0) {
  FdmStepConditionDelegate *obj = (FdmStepConditionDelegate *)objarg;
  SwigDirector_FdmStepConditionDelegate *director = static_cast<SwigDirector_FdmStepConditionDelegate *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FdmInnerValueCalculator_innerValue(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  FdmInnerValueCalculator *arg1 = (FdmInnerValueCalculator *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< FdmInnerValueCalculator > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  FdmInnerValueCalculator > *)jarg1;
  arg1 = (FdmInnerValueCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (FdmLinearOpIterator *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmLinearOpIterator const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)(arg1)->innerValue((FdmLinearOpIterator 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_FdmInnerValueCalculator_avgInnerValue(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  FdmInnerValueCalculator *arg1 = (FdmInnerValueCalculator *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Time arg3 ;
  ext::shared_ptr< FdmInnerValueCalculator > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  FdmInnerValueCalculator > *)jarg1;
  arg1 = (FdmInnerValueCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (FdmLinearOpIterator *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmLinearOpIterator const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)(arg1)->avgInnerValue((FdmLinearOpIterator 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 void SWIGSTDCALL CSharp_QuantLib_delete_FdmInnerValueCalculator(void * jarg1) {
  FdmInnerValueCalculator *arg1 = (FdmInnerValueCalculator *) 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmInnerValueCalculator > *)jarg1;
  arg1 = (FdmInnerValueCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmInnerValueCalculatorProxy(void * jarg1) {
  void * jresult ;
  FdmInnerValueCalculatorDelegate *arg1 = (FdmInnerValueCalculatorDelegate *) 0 ;
  FdmInnerValueCalculatorProxy *result = 0 ;
  
  arg1 = (FdmInnerValueCalculatorDelegate *)jarg1; 
  {
    try {
      result = (FdmInnerValueCalculatorProxy *)new FdmInnerValueCalculatorProxy(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdmInnerValueCalculatorProxy >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmInnerValueCalculatorProxy(void * jarg1) {
  FdmInnerValueCalculatorProxy *arg1 = (FdmInnerValueCalculatorProxy *) 0 ;
  ext::shared_ptr< FdmInnerValueCalculatorProxy > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmInnerValueCalculatorProxy > *)jarg1;
  arg1 = (FdmInnerValueCalculatorProxy *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_FdmInnerValueCalculatorDelegate(void * jarg1) {
  FdmInnerValueCalculatorDelegate *arg1 = (FdmInnerValueCalculatorDelegate *) 0 ;
  
  arg1 = (FdmInnerValueCalculatorDelegate *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_FdmInnerValueCalculatorDelegate_innerValue(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  FdmInnerValueCalculatorDelegate *arg1 = (FdmInnerValueCalculatorDelegate *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Time arg3 ;
  Real result;
  
  arg1 = (FdmInnerValueCalculatorDelegate *)jarg1; 
  arg2 = (FdmLinearOpIterator *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmLinearOpIterator const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)(arg1)->innerValue((FdmLinearOpIterator 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_FdmInnerValueCalculatorDelegate_innerValueSwigExplicitFdmInnerValueCalculatorDelegate(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  FdmInnerValueCalculatorDelegate *arg1 = (FdmInnerValueCalculatorDelegate *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Time arg3 ;
  Real result;
  
  arg1 = (FdmInnerValueCalculatorDelegate *)jarg1; 
  arg2 = (FdmLinearOpIterator *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmLinearOpIterator const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)(arg1)->FdmInnerValueCalculatorDelegate::innerValue((FdmLinearOpIterator 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_FdmInnerValueCalculatorDelegate_avgInnerValue(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  FdmInnerValueCalculatorDelegate *arg1 = (FdmInnerValueCalculatorDelegate *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Time arg3 ;
  Real result;
  
  arg1 = (FdmInnerValueCalculatorDelegate *)jarg1; 
  arg2 = (FdmLinearOpIterator *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmLinearOpIterator const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)(arg1)->avgInnerValue((FdmLinearOpIterator 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_FdmInnerValueCalculatorDelegate_avgInnerValueSwigExplicitFdmInnerValueCalculatorDelegate(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  FdmInnerValueCalculatorDelegate *arg1 = (FdmInnerValueCalculatorDelegate *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Time arg3 ;
  Real result;
  
  arg1 = (FdmInnerValueCalculatorDelegate *)jarg1; 
  arg2 = (FdmLinearOpIterator *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmLinearOpIterator const & is null", 0);
    return 0;
  } 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)(arg1)->FdmInnerValueCalculatorDelegate::avgInnerValue((FdmLinearOpIterator 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 void * SWIGSTDCALL CSharp_QuantLib_new_FdmInnerValueCalculatorDelegate() {
  void * jresult ;
  FdmInnerValueCalculatorDelegate *result = 0 ;
  
  {
    try {
      result = (FdmInnerValueCalculatorDelegate *)new SwigDirector_FdmInnerValueCalculatorDelegate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FdmInnerValueCalculatorDelegate_director_connect(void *objarg, SwigDirector_FdmInnerValueCalculatorDelegate::SWIG_Callback0_t callback0, SwigDirector_FdmInnerValueCalculatorDelegate::SWIG_Callback1_t callback1) {
  FdmInnerValueCalculatorDelegate *obj = (FdmInnerValueCalculatorDelegate *)objarg;
  SwigDirector_FdmInnerValueCalculatorDelegate *director = static_cast<SwigDirector_FdmInnerValueCalculatorDelegate *>(obj);
  director->swig_connect_director(callback0, callback1);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmCellAveragingInnerValue__SWIG_0(void * jarg1, void * jarg2, unsigned long jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< Payoff > *arg1 = 0 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  Size arg3 ;
  UnaryFunctionDelegate *arg4 = (UnaryFunctionDelegate *) 0 ;
  ext::shared_ptr< Payoff > tempnull1 ;
  ext::shared_ptr< FdmMesher > tempnull2 ;
  FdmCellAveragingInnerValue *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Payoff > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmMesher > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (UnaryFunctionDelegate *)jarg4; 
  {
    try {
      result = (FdmCellAveragingInnerValue *)new_FdmCellAveragingInnerValue__SWIG_0((ext::shared_ptr< Payoff > const &)*arg1,(ext::shared_ptr< FdmMesher > const &)*arg2,SWIG_STD_MOVE(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 ? new ext::shared_ptr<  FdmCellAveragingInnerValue >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmCellAveragingInnerValue__SWIG_1(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< Payoff > *arg1 = 0 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  Size arg3 ;
  ext::shared_ptr< Payoff > tempnull1 ;
  ext::shared_ptr< FdmMesher > tempnull2 ;
  FdmCellAveragingInnerValue *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Payoff > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmMesher > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdmCellAveragingInnerValue *)new_FdmCellAveragingInnerValue__SWIG_1((ext::shared_ptr< Payoff > const &)*arg1,(ext::shared_ptr< FdmMesher > const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdmCellAveragingInnerValue >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmCellAveragingInnerValue(void * jarg1) {
  FdmCellAveragingInnerValue *arg1 = (FdmCellAveragingInnerValue *) 0 ;
  ext::shared_ptr< FdmCellAveragingInnerValue > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmCellAveragingInnerValue > *)jarg1;
  arg1 = (FdmCellAveragingInnerValue *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmLogInnerValue(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< Payoff > *arg1 = 0 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  Size arg3 ;
  ext::shared_ptr< Payoff > tempnull1 ;
  ext::shared_ptr< FdmMesher > tempnull2 ;
  FdmLogInnerValue *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Payoff > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmMesher > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdmLogInnerValue *)new FdmLogInnerValue((ext::shared_ptr< Payoff > const &)*arg1,(ext::shared_ptr< FdmMesher > 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 ? new ext::shared_ptr<  FdmLogInnerValue >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmLogInnerValue(void * jarg1) {
  FdmLogInnerValue *arg1 = (FdmLogInnerValue *) 0 ;
  ext::shared_ptr< FdmLogInnerValue > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmLogInnerValue > *)jarg1;
  arg1 = (FdmLogInnerValue *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmLogBasketInnerValue(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< BasketPayoff > *arg1 = 0 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  ext::shared_ptr< BasketPayoff > tempnull1 ;
  ext::shared_ptr< FdmMesher > tempnull2 ;
  FdmLogBasketInnerValue *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BasketPayoff > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmMesher > *)jarg2 : &tempnull2; 
  {
    try {
      result = (FdmLogBasketInnerValue *)new FdmLogBasketInnerValue((ext::shared_ptr< BasketPayoff > const &)*arg1,(ext::shared_ptr< FdmMesher > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdmLogBasketInnerValue >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmLogBasketInnerValue(void * jarg1) {
  FdmLogBasketInnerValue *arg1 = (FdmLogBasketInnerValue *) 0 ;
  ext::shared_ptr< FdmLogBasketInnerValue > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmLogBasketInnerValue > *)jarg1;
  arg1 = (FdmLogBasketInnerValue *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmZeroInnerValue(void * jarg1) {
  FdmZeroInnerValue *arg1 = (FdmZeroInnerValue *) 0 ;
  ext::shared_ptr< FdmZeroInnerValue > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmZeroInnerValue > *)jarg1;
  arg1 = (FdmZeroInnerValue *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TimeToDateMap__SWIG_0() {
  void * jresult ;
  std::map< Time,Date > *result = 0 ;
  
  {
    try {
      result = (std::map< Time,Date > *)new std::map< Time,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_TimeToDateMap__SWIG_1(void * jarg1) {
  void * jresult ;
  std::map< Time,Date > *arg1 = 0 ;
  std::map< Time,Date > *result = 0 ;
  
  arg1 = (std::map< Time,Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< Time,Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::map< Time,Date > *)new std::map< Time,Date >((std::map< Time,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 unsigned long SWIGSTDCALL CSharp_QuantLib_TimeToDateMap_size(void * jarg1) {
  unsigned long jresult ;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::size_type result;
  
  arg1 = (std::map< Time,Date > *)jarg1; 
  {
    try {
      result = ((std::map< Time,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 int SWIGSTDCALL CSharp_QuantLib_TimeToDateMap_empty(void * jarg1) {
  unsigned int jresult ;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  bool result;
  
  arg1 = (std::map< Time,Date > *)jarg1; 
  {
    try {
      result = (bool)((std::map< Time,Date > 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_TimeToDateMap_Clear(void * jarg1) {
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  
  arg1 = (std::map< Time,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_TimeToDateMap_getitem(void * jarg1, double jarg2) {
  void * jresult ;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::key_type *arg2 = 0 ;
  std::map< double,Date >::key_type temp2 ;
  std::map< double,Date >::mapped_type *result = 0 ;
  
  arg1 = (std::map< Time,Date > *)jarg1; 
  temp2 = (std::map< double,Date >::key_type)jarg2; 
  arg2 = &temp2; 
  {
    try {
      try {
        result = (std::map< double,Date >::mapped_type *) &std_map_Sl_Time_Sc_Date_Sg__getitem(arg1,(double const &)*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_TimeToDateMap_setitem(void * jarg1, double jarg2, void * jarg3) {
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::key_type *arg2 = 0 ;
  std::map< double,Date >::mapped_type *arg3 = 0 ;
  std::map< double,Date >::key_type temp2 ;
  
  arg1 = (std::map< Time,Date > *)jarg1; 
  temp2 = (std::map< double,Date >::key_type)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::map< double,Date >::mapped_type *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< double,Date >::mapped_type const & is null", 0);
    return ;
  } 
  {
    try {
      std_map_Sl_Time_Sc_Date_Sg__setitem(arg1,(double 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 unsigned int SWIGSTDCALL CSharp_QuantLib_TimeToDateMap_ContainsKey(void * jarg1, double jarg2) {
  unsigned int jresult ;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::key_type *arg2 = 0 ;
  std::map< double,Date >::key_type temp2 ;
  bool result;
  
  arg1 = (std::map< Time,Date > *)jarg1; 
  temp2 = (std::map< double,Date >::key_type)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (bool)std_map_Sl_Time_Sc_Date_Sg__ContainsKey(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_TimeToDateMap_Add(void * jarg1, double jarg2, void * jarg3) {
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::key_type *arg2 = 0 ;
  std::map< double,Date >::mapped_type *arg3 = 0 ;
  std::map< double,Date >::key_type temp2 ;
  
  arg1 = (std::map< Time,Date > *)jarg1; 
  temp2 = (std::map< double,Date >::key_type)jarg2; 
  arg2 = &temp2; 
  arg3 = (std::map< double,Date >::mapped_type *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< double,Date >::mapped_type const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_map_Sl_Time_Sc_Date_Sg__Add(arg1,(double const &)*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 unsigned int SWIGSTDCALL CSharp_QuantLib_TimeToDateMap_Remove(void * jarg1, double jarg2) {
  unsigned int jresult ;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::key_type *arg2 = 0 ;
  std::map< double,Date >::key_type temp2 ;
  bool result;
  
  arg1 = (std::map< Time,Date > *)jarg1; 
  temp2 = (std::map< double,Date >::key_type)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (bool)std_map_Sl_Time_Sc_Date_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_TimeToDateMap_create_iterator_begin(void * jarg1) {
  void * jresult ;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date,std::less< double > >::iterator *result = 0 ;
  
  arg1 = (std::map< Time,Date > *)jarg1; 
  {
    try {
      result = (std::map< double,Date,std::less< double > >::iterator *)std_map_Sl_Time_Sc_Date_Sg__create_iterator_begin(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_TimeToDateMap_get_next_key(void * jarg1, void * jarg2) {
  double jresult ;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date,std::less< double > >::iterator *arg2 = (std::map< double,Date,std::less< double > >::iterator *) 0 ;
  std::map< double,Date >::key_type *result = 0 ;
  
  arg1 = (std::map< Time,Date > *)jarg1; 
  arg2 = (std::map< double,Date,std::less< double > >::iterator *)jarg2; 
  {
    try {
      result = (std::map< double,Date >::key_type *) &std_map_Sl_Time_Sc_Date_Sg__get_next_key(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_TimeToDateMap_destroy_iterator(void * jarg1, void * jarg2) {
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date,std::less< double > >::iterator *arg2 = (std::map< double,Date,std::less< double > >::iterator *) 0 ;
  
  arg1 = (std::map< Time,Date > *)jarg1; 
  arg2 = (std::map< double,Date,std::less< double > >::iterator *)jarg2; 
  {
    try {
      std_map_Sl_Time_Sc_Date_Sg__destroy_iterator(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_TimeToDateMap(void * jarg1) {
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  
  arg1 = (std::map< Time,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_new_FdmAffineG2ModelSwapInnerValue(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  ext::shared_ptr< G2 > *arg2 = 0 ;
  ext::shared_ptr< VanillaSwap > *arg3 = 0 ;
  std::map< Time,Date,std::less< Time > > *arg4 = 0 ;
  ext::shared_ptr< FdmMesher > *arg5 = 0 ;
  Size arg6 ;
  ext::shared_ptr< G2 > tempnull1 ;
  ext::shared_ptr< G2 > tempnull2 ;
  ext::shared_ptr< VanillaSwap > tempnull3 ;
  ext::shared_ptr< FdmMesher > tempnull5 ;
  FdmAffineModelSwapInnerValue< G2 > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< G2 > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< G2 > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< VanillaSwap > *)jarg3 : &tempnull3; 
  arg4 = (std::map< Time,Date,std::less< Time > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< Time,Date,std::less< Time > > const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< FdmMesher > *)jarg5 : &tempnull5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdmAffineModelSwapInnerValue< G2 > *)new FdmAffineModelSwapInnerValue< G2 >((ext::shared_ptr< G2 > const &)*arg1,(ext::shared_ptr< G2 > const &)*arg2,(ext::shared_ptr< VanillaSwap > const &)*arg3,(std::map< Time,Date,std::less< Time > > const &)*arg4,(ext::shared_ptr< FdmMesher > 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 ? new ext::shared_ptr<  FdmAffineModelSwapInnerValue<G2> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmAffineG2ModelSwapInnerValue(void * jarg1) {
  FdmAffineModelSwapInnerValue< G2 > *arg1 = (FdmAffineModelSwapInnerValue< G2 > *) 0 ;
  ext::shared_ptr< FdmAffineModelSwapInnerValue< G2 > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmAffineModelSwapInnerValue<G2> > *)jarg1;
  arg1 = (FdmAffineModelSwapInnerValue<G2> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmAffineHullWhiteModelSwapInnerValue(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > *arg2 = 0 ;
  ext::shared_ptr< VanillaSwap > *arg3 = 0 ;
  std::map< Time,Date,std::less< Time > > *arg4 = 0 ;
  ext::shared_ptr< FdmMesher > *arg5 = 0 ;
  Size arg6 ;
  ext::shared_ptr< HullWhite > tempnull1 ;
  ext::shared_ptr< HullWhite > tempnull2 ;
  ext::shared_ptr< VanillaSwap > tempnull3 ;
  ext::shared_ptr< FdmMesher > tempnull5 ;
  FdmAffineModelSwapInnerValue< HullWhite > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HullWhite > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HullWhite > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< VanillaSwap > *)jarg3 : &tempnull3; 
  arg4 = (std::map< Time,Date,std::less< Time > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< Time,Date,std::less< Time > > const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? (ext::shared_ptr< FdmMesher > *)jarg5 : &tempnull5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FdmAffineModelSwapInnerValue< HullWhite > *)new FdmAffineModelSwapInnerValue< HullWhite >((ext::shared_ptr< HullWhite > const &)*arg1,(ext::shared_ptr< HullWhite > const &)*arg2,(ext::shared_ptr< VanillaSwap > const &)*arg3,(std::map< Time,Date,std::less< Time > > const &)*arg4,(ext::shared_ptr< FdmMesher > 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 ? new ext::shared_ptr<  FdmAffineModelSwapInnerValue<HullWhite> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmAffineHullWhiteModelSwapInnerValue(void * jarg1) {
  FdmAffineModelSwapInnerValue< HullWhite > *arg1 = (FdmAffineModelSwapInnerValue< HullWhite > *) 0 ;
  ext::shared_ptr< FdmAffineModelSwapInnerValue< HullWhite > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmAffineModelSwapInnerValue<HullWhite> > *)jarg1;
  arg1 = (FdmAffineModelSwapInnerValue<HullWhite> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmSnapshotCondition(double jarg1) {
  void * jresult ;
  Time arg1 ;
  FdmSnapshotCondition *result = 0 ;
  
  arg1 = (Time)jarg1; 
  {
    try {
      result = (FdmSnapshotCondition *)new FdmSnapshotCondition(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdmSnapshotCondition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FdmSnapshotCondition_getTime(void * jarg1) {
  double jresult ;
  FdmSnapshotCondition *arg1 = (FdmSnapshotCondition *) 0 ;
  ext::shared_ptr< FdmSnapshotCondition const > *smartarg1 = 0 ;
  Time result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmSnapshotCondition > *)jarg1;
  arg1 = (FdmSnapshotCondition *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Time)((FdmSnapshotCondition const *)arg1)->getTime();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmSnapshotCondition_getValues(void * jarg1) {
  void * jresult ;
  FdmSnapshotCondition *arg1 = (FdmSnapshotCondition *) 0 ;
  ext::shared_ptr< FdmSnapshotCondition const > *smartarg1 = 0 ;
  Array *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const FdmSnapshotCondition > *)jarg1;
  arg1 = (FdmSnapshotCondition *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Array *) &((FdmSnapshotCondition const *)arg1)->getValues();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmSnapshotCondition(void * jarg1) {
  FdmSnapshotCondition *arg1 = (FdmSnapshotCondition *) 0 ;
  ext::shared_ptr< FdmSnapshotCondition > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmSnapshotCondition > *)jarg1;
  arg1 = (FdmSnapshotCondition *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FdmStepConditionVector_Clear(void * jarg1) {
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)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_FdmStepConditionVector_Add(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  ext::shared_ptr< StepCondition< Array > > *arg2 = 0 ;
  ext::shared_ptr< StepCondition< Array > > tempnull2 ;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StepCondition< Array > > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->push_back((ext::shared_ptr< StepCondition< 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 unsigned long SWIGSTDCALL CSharp_QuantLib_FdmStepConditionVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< StepCondition< 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 unsigned long SWIGSTDCALL CSharp_QuantLib_FdmStepConditionVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type result;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  {
    try {
      result = ((std::vector< ext::shared_ptr< StepCondition< Array > > > 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_FdmStepConditionVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< StepCondition< Array > > >::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_FdmStepConditionVector__SWIG_0() {
  void * jresult ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *result = 0 ;
  
  {
    try {
      result = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)new std::vector< ext::shared_ptr< StepCondition< 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_FdmStepConditionVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< StepCondition< Array > > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)new std::vector< ext::shared_ptr< StepCondition< Array > > >((std::vector< ext::shared_ptr< StepCondition< 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_FdmStepConditionVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)new_std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_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_FdmStepConditionVector_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< StepCondition< Array > > result;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_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 = result ? new ext::shared_ptr< StepCondition< Array > >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmStepConditionVector_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_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 = *result ? new std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FdmStepConditionVector_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< StepCondition< Array > > *arg3 = 0 ;
  ext::shared_ptr< StepCondition< Array > > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< StepCondition< Array > > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__setitem(arg1,arg2,(ext::shared_ptr< StepCondition< Array > > 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_FdmStepConditionVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg2 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< StepCondition< Array > > > const & is null", 0);
    return ;
  } 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__AddRange(arg1,(std::vector< ext::shared_ptr< StepCondition< 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_FdmStepConditionVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_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_FdmStepConditionVector_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  int arg2 ;
  ext::shared_ptr< StepCondition< Array > > *arg3 = 0 ;
  ext::shared_ptr< StepCondition< Array > > tempnull3 ;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (ext::shared_ptr< StepCondition< Array > > *)jarg3 : &tempnull3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__Insert(arg1,arg2,(ext::shared_ptr< StepCondition< Array > > 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_FdmStepConditionVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< StepCondition< Array > > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__InsertRange(arg1,arg2,(std::vector< ext::shared_ptr< StepCondition< Array > > > 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_FdmStepConditionVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_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_FdmStepConditionVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_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_FdmStepConditionVector_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< StepCondition< Array > > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< StepCondition< Array > > tempnull1 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StepCondition< Array > > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__Repeat((ext::shared_ptr< StepCondition< Array > > 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_FdmStepConditionVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_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_FdmStepConditionVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_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_FdmStepConditionVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  int arg2 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg3 = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< StepCondition< Array > > > const & is null", 0);
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__SetRange(arg1,arg2,(std::vector< ext::shared_ptr< StepCondition< Array > > > 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_FdmStepConditionVector_Contains(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  ext::shared_ptr< StepCondition< Array > > *arg2 = 0 ;
  ext::shared_ptr< StepCondition< Array > > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StepCondition< Array > > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__Contains(arg1,(ext::shared_ptr< StepCondition< 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 int SWIGSTDCALL CSharp_QuantLib_FdmStepConditionVector_IndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  ext::shared_ptr< StepCondition< Array > > *arg2 = 0 ;
  ext::shared_ptr< StepCondition< Array > > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StepCondition< Array > > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__IndexOf(arg1,(ext::shared_ptr< StepCondition< 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 int SWIGSTDCALL CSharp_QuantLib_FdmStepConditionVector_LastIndexOf(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  ext::shared_ptr< StepCondition< Array > > *arg2 = 0 ;
  ext::shared_ptr< StepCondition< Array > > tempnull2 ;
  int result;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StepCondition< Array > > *)jarg2 : &tempnull2; 
  {
    try {
      result = (int)std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__LastIndexOf(arg1,(ext::shared_ptr< StepCondition< 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 int SWIGSTDCALL CSharp_QuantLib_FdmStepConditionVector_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  ext::shared_ptr< StepCondition< Array > > *arg2 = 0 ;
  ext::shared_ptr< StepCondition< Array > > tempnull2 ;
  bool result;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StepCondition< Array > > *)jarg2 : &tempnull2; 
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__Remove(arg1,(ext::shared_ptr< StepCondition< 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_delete_FdmStepConditionVector(void * jarg1) {
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< StepCondition< 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_new_FdmStepConditionComposite(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg2 = 0 ;
  FdmStepConditionComposite *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< StepCondition< Array > > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmStepConditionComposite *)new_FdmStepConditionComposite((std::vector< double > const &)*arg1,(std::vector< ext::shared_ptr< StepCondition< 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 ? new ext::shared_ptr<  FdmStepConditionComposite >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmStepConditionComposite_stoppingTimes(void * jarg1) {
  void * jresult ;
  FdmStepConditionComposite *arg1 = (FdmStepConditionComposite *) 0 ;
  ext::shared_ptr< FdmStepConditionComposite const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const FdmStepConditionComposite > *)jarg1;
  arg1 = (FdmStepConditionComposite *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((FdmStepConditionComposite const *)arg1)->stoppingTimes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmStepConditionComposite_conditions(void * jarg1) {
  void * jresult ;
  FdmStepConditionComposite *arg1 = (FdmStepConditionComposite *) 0 ;
  ext::shared_ptr< FdmStepConditionComposite const > *smartarg1 = 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const FdmStepConditionComposite > *)jarg1;
  arg1 = (FdmStepConditionComposite *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) &((FdmStepConditionComposite const *)arg1)->conditions();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmStepConditionComposite_joinConditions(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< FdmSnapshotCondition > *arg1 = 0 ;
  ext::shared_ptr< FdmStepConditionComposite > *arg2 = 0 ;
  ext::shared_ptr< FdmSnapshotCondition > tempnull1 ;
  ext::shared_ptr< FdmStepConditionComposite > tempnull2 ;
  ext::shared_ptr< FdmStepConditionComposite > result;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmSnapshotCondition > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmStepConditionComposite > *)jarg2 : &tempnull2; 
  {
    try {
      result = FdmStepConditionComposite::joinConditions((ext::shared_ptr< FdmSnapshotCondition > const &)*arg1,(ext::shared_ptr< FdmStepConditionComposite > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< FdmStepConditionComposite >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmStepConditionComposite_vanillaComposite(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  ext::shared_ptr< FdmMesher > *arg3 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > *arg4 = 0 ;
  Date *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  ext::shared_ptr< FdmMesher > tempnull3 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempnull4 ;
  ext::shared_ptr< FdmStepConditionComposite > result;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Dividend > > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmMesher > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< FdmInnerValueCalculator > *)jarg4 : &tempnull4; 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = FdmStepConditionComposite::vanillaComposite((std::vector< ext::shared_ptr< Dividend > > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2,(ext::shared_ptr< FdmMesher > const &)*arg3,(ext::shared_ptr< FdmInnerValueCalculator > const &)*arg4,(Date 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 = result ? new ext::shared_ptr< FdmStepConditionComposite >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmStepConditionComposite(void * jarg1) {
  FdmStepConditionComposite *arg1 = (FdmStepConditionComposite *) 0 ;
  ext::shared_ptr< FdmStepConditionComposite > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmStepConditionComposite > *)jarg1;
  arg1 = (FdmStepConditionComposite *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmAmericanStepCondition(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > *arg2 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempnull2 ;
  FdmAmericanStepCondition *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< FdmInnerValueCalculator > *)jarg2 : &tempnull2; 
  {
    try {
      result = (FdmAmericanStepCondition *)new FdmAmericanStepCondition((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< FdmInnerValueCalculator > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdmAmericanStepCondition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmAmericanStepCondition(void * jarg1) {
  FdmAmericanStepCondition *arg1 = (FdmAmericanStepCondition *) 0 ;
  ext::shared_ptr< FdmAmericanStepCondition > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmAmericanStepCondition > *)jarg1;
  arg1 = (FdmAmericanStepCondition *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmArithmeticAverageCondition(void * jarg1, double jarg2, unsigned long jarg3, void * jarg4, unsigned long jarg5) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  ext::shared_ptr< FdmMesher > *arg4 = 0 ;
  Size arg5 ;
  ext::shared_ptr< FdmMesher > tempnull4 ;
  FdmArithmeticAverageCondition *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = jarg4 ? (ext::shared_ptr< FdmMesher > *)jarg4 : &tempnull4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdmArithmeticAverageCondition *)new FdmArithmeticAverageCondition((std::vector< Time > const &)*arg1,arg2,arg3,(ext::shared_ptr< FdmMesher > 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 ? new ext::shared_ptr<  FdmArithmeticAverageCondition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmArithmeticAverageCondition(void * jarg1) {
  FdmArithmeticAverageCondition *arg1 = (FdmArithmeticAverageCondition *) 0 ;
  ext::shared_ptr< FdmArithmeticAverageCondition > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmArithmeticAverageCondition > *)jarg1;
  arg1 = (FdmArithmeticAverageCondition *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBermudanStepCondition(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  ext::shared_ptr< FdmMesher > *arg4 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > *arg5 = 0 ;
  ext::shared_ptr< FdmMesher > tempnull4 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempnull5 ;
  FdmBermudanStepCondition *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< FdmMesher > *)jarg4 : &tempnull4; 
  arg5 = jarg5 ? (ext::shared_ptr< FdmInnerValueCalculator > *)jarg5 : &tempnull5; 
  {
    try {
      result = (FdmBermudanStepCondition *)new FdmBermudanStepCondition((std::vector< Date > const &)*arg1,(Date const &)*arg2,(DayCounter const &)*arg3,(ext::shared_ptr< FdmMesher > const &)*arg4,(ext::shared_ptr< FdmInnerValueCalculator > 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 ? new ext::shared_ptr<  FdmBermudanStepCondition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmBermudanStepCondition_exerciseTimes(void * jarg1) {
  void * jresult ;
  FdmBermudanStepCondition *arg1 = (FdmBermudanStepCondition *) 0 ;
  ext::shared_ptr< FdmBermudanStepCondition const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const FdmBermudanStepCondition > *)jarg1;
  arg1 = (FdmBermudanStepCondition *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((FdmBermudanStepCondition const *)arg1)->exerciseTimes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmBermudanStepCondition(void * jarg1) {
  FdmBermudanStepCondition *arg1 = (FdmBermudanStepCondition *) 0 ;
  ext::shared_ptr< FdmBermudanStepCondition > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmBermudanStepCondition > *)jarg1;
  arg1 = (FdmBermudanStepCondition *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmSimpleStorageCondition(void * jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< FdmMesher > tempnull2 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempnull3 ;
  FdmSimpleStorageCondition *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< FdmMesher > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmInnerValueCalculator > *)jarg3 : &tempnull3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (FdmSimpleStorageCondition *)new FdmSimpleStorageCondition((std::vector< Time > const &)*arg1,(ext::shared_ptr< FdmMesher > const &)*arg2,(ext::shared_ptr< FdmInnerValueCalculator > 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 ? new ext::shared_ptr<  FdmSimpleStorageCondition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmSimpleStorageCondition(void * jarg1) {
  FdmSimpleStorageCondition *arg1 = (FdmSimpleStorageCondition *) 0 ;
  ext::shared_ptr< FdmSimpleStorageCondition > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmSimpleStorageCondition > *)jarg1;
  arg1 = (FdmSimpleStorageCondition *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmSimpleSwingCondition__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< FdmMesher > tempnull2 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempnull3 ;
  FdmSimpleSwingCondition *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< FdmMesher > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmInnerValueCalculator > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdmSimpleSwingCondition *)new FdmSimpleSwingCondition((std::vector< Time > const &)*arg1,(ext::shared_ptr< FdmMesher > const &)*arg2,(ext::shared_ptr< FdmInnerValueCalculator > 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 ? new ext::shared_ptr<  FdmSimpleSwingCondition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmSimpleSwingCondition__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > *arg3 = 0 ;
  Size arg4 ;
  ext::shared_ptr< FdmMesher > tempnull2 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempnull3 ;
  FdmSimpleSwingCondition *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< FdmMesher > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< FdmInnerValueCalculator > *)jarg3 : &tempnull3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdmSimpleSwingCondition *)new FdmSimpleSwingCondition((std::vector< Time > const &)*arg1,(ext::shared_ptr< FdmMesher > const &)*arg2,(ext::shared_ptr< FdmInnerValueCalculator > 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 ? new ext::shared_ptr<  FdmSimpleSwingCondition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmSimpleSwingCondition(void * jarg1) {
  FdmSimpleSwingCondition *arg1 = (FdmSimpleSwingCondition *) 0 ;
  ext::shared_ptr< FdmSimpleSwingCondition > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmSimpleSwingCondition > *)jarg1;
  arg1 = (FdmSimpleSwingCondition *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmDividendHandler(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5) {
  void * jresult ;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = 0 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Size arg5 ;
  ext::shared_ptr< FdmMesher > tempnull2 ;
  FdmDividendHandler *result = 0 ;
  
  arg1 = (std::vector< ext::shared_ptr< Dividend > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< Dividend > > const & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (ext::shared_ptr< FdmMesher > *)jarg2 : &tempnull2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdmDividendHandler *)new FdmDividendHandler((std::vector< ext::shared_ptr< Dividend > > const &)*arg1,(ext::shared_ptr< FdmMesher > 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 = result ? new ext::shared_ptr<  FdmDividendHandler >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmDividendHandler_dividendTimes(void * jarg1) {
  void * jresult ;
  FdmDividendHandler *arg1 = (FdmDividendHandler *) 0 ;
  ext::shared_ptr< FdmDividendHandler const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const FdmDividendHandler > *)jarg1;
  arg1 = (FdmDividendHandler *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((FdmDividendHandler const *)arg1)->dividendTimes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmDividendHandler_dividendDates(void * jarg1) {
  void * jresult ;
  FdmDividendHandler *arg1 = (FdmDividendHandler *) 0 ;
  ext::shared_ptr< FdmDividendHandler const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const FdmDividendHandler > *)jarg1;
  arg1 = (FdmDividendHandler *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((FdmDividendHandler const *)arg1)->dividendDates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmDividendHandler_dividends(void * jarg1) {
  void * jresult ;
  FdmDividendHandler *arg1 = (FdmDividendHandler *) 0 ;
  ext::shared_ptr< FdmDividendHandler const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const FdmDividendHandler > *)jarg1;
  arg1 = (FdmDividendHandler *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((FdmDividendHandler const *)arg1)->dividends();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmDividendHandler(void * jarg1) {
  FdmDividendHandler *arg1 = (FdmDividendHandler *) 0 ;
  ext::shared_ptr< FdmDividendHandler > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmDividendHandler > *)jarg1;
  arg1 = (FdmDividendHandler *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmSolverDesc(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5, unsigned long jarg6, unsigned long jarg7) {
  void * jresult ;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  FdmBoundaryConditionSet *arg2 = 0 ;
  ext::shared_ptr< FdmStepConditionComposite > *arg3 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > *arg4 = 0 ;
  Time arg5 ;
  Size arg6 ;
  Size arg7 ;
  ext::shared_ptr< FdmMesher > tempnull1 ;
  ext::shared_ptr< FdmStepConditionComposite > tempnull3 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempnull4 ;
  FdmSolverDesc *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmMesher > *)jarg1 : &tempnull1; 
  arg2 = (FdmBoundaryConditionSet *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmBoundaryConditionSet const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< FdmStepConditionComposite > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< FdmInnerValueCalculator > *)jarg4 : &tempnull4; 
  arg5 = (Time)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (FdmSolverDesc *)new_FdmSolverDesc((ext::shared_ptr< FdmMesher > const &)*arg1,(std::vector< ext::shared_ptr< FdmBoundaryCondition > > const &)*arg2,(ext::shared_ptr< FdmStepConditionComposite > const &)*arg3,(ext::shared_ptr< FdmInnerValueCalculator > const &)*arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(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_FdmSolverDesc_getMesher(void * jarg1) {
  void * jresult ;
  FdmSolverDesc *arg1 = (FdmSolverDesc *) 0 ;
  ext::shared_ptr< FdmMesher > result;
  
  arg1 = (FdmSolverDesc *)jarg1; 
  {
    try {
      result = FdmSolverDesc_getMesher((FdmSolverDesc const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< FdmMesher >(result) : 0; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmSolverDesc_getStepConditions(void * jarg1) {
  void * jresult ;
  FdmSolverDesc *arg1 = (FdmSolverDesc *) 0 ;
  ext::shared_ptr< FdmStepConditionComposite > result;
  
  arg1 = (FdmSolverDesc *)jarg1; 
  {
    try {
      result = FdmSolverDesc_getStepConditions((FdmSolverDesc const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< FdmStepConditionComposite >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmSolverDesc_getCalculator(void * jarg1) {
  void * jresult ;
  FdmSolverDesc *arg1 = (FdmSolverDesc *) 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > result;
  
  arg1 = (FdmSolverDesc *)jarg1; 
  {
    try {
      result = FdmSolverDesc_getCalculator((FdmSolverDesc const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< FdmInnerValueCalculator >(result) : 0; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FdmSolverDesc_getMaturity(void * jarg1) {
  double jresult ;
  FdmSolverDesc *arg1 = (FdmSolverDesc *) 0 ;
  Time result;
  
  arg1 = (FdmSolverDesc *)jarg1; 
  {
    try {
      result = (Time)FdmSolverDesc_getMaturity((FdmSolverDesc const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_FdmSolverDesc_getTimeSteps(void * jarg1) {
  unsigned long jresult ;
  FdmSolverDesc *arg1 = (FdmSolverDesc *) 0 ;
  Size result;
  
  arg1 = (FdmSolverDesc *)jarg1; 
  {
    try {
      result = FdmSolverDesc_getTimeSteps((FdmSolverDesc const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_FdmSolverDesc_getDampingSteps(void * jarg1) {
  unsigned long jresult ;
  FdmSolverDesc *arg1 = (FdmSolverDesc *) 0 ;
  Size result;
  
  arg1 = (FdmSolverDesc *)jarg1; 
  {
    try {
      result = FdmSolverDesc_getDampingSteps((FdmSolverDesc const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_FdmSolverDesc(void * jarg1) {
  FdmSolverDesc *arg1 = (FdmSolverDesc *) 0 ;
  
  arg1 = (FdmSolverDesc *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fdm1DimSolver(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  FdmSolverDesc *arg1 = 0 ;
  FdmSchemeDesc *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull3 ;
  Fdm1DimSolver *result = 0 ;
  
  arg1 = (FdmSolverDesc *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  arg2 = (FdmSchemeDesc *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg3 : &tempnull3; 
  {
    try {
      result = (Fdm1DimSolver *)new Fdm1DimSolver((FdmSolverDesc const &)*arg1,(FdmSchemeDesc const &)*arg2,(ext::shared_ptr< FdmLinearOpComposite > 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 ? new ext::shared_ptr<  Fdm1DimSolver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Fdm1DimSolver_interpolateAt(void * jarg1, double jarg2) {
  double jresult ;
  Fdm1DimSolver *arg1 = (Fdm1DimSolver *) 0 ;
  Real arg2 ;
  ext::shared_ptr< Fdm1DimSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm1DimSolver > *)jarg1;
  arg1 = (Fdm1DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((Fdm1DimSolver const *)arg1)->interpolateAt(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Fdm1DimSolver_thetaAt(void * jarg1, double jarg2) {
  double jresult ;
  Fdm1DimSolver *arg1 = (Fdm1DimSolver *) 0 ;
  Real arg2 ;
  ext::shared_ptr< Fdm1DimSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm1DimSolver > *)jarg1;
  arg1 = (Fdm1DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((Fdm1DimSolver const *)arg1)->thetaAt(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Fdm1DimSolver_derivativeX(void * jarg1, double jarg2) {
  double jresult ;
  Fdm1DimSolver *arg1 = (Fdm1DimSolver *) 0 ;
  Real arg2 ;
  ext::shared_ptr< Fdm1DimSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm1DimSolver > *)jarg1;
  arg1 = (Fdm1DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((Fdm1DimSolver const *)arg1)->derivativeX(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Fdm1DimSolver_derivativeXX(void * jarg1, double jarg2) {
  double jresult ;
  Fdm1DimSolver *arg1 = (Fdm1DimSolver *) 0 ;
  Real arg2 ;
  ext::shared_ptr< Fdm1DimSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm1DimSolver > *)jarg1;
  arg1 = (Fdm1DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((Fdm1DimSolver const *)arg1)->derivativeXX(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_Fdm1DimSolver(void * jarg1) {
  Fdm1DimSolver *arg1 = (Fdm1DimSolver *) 0 ;
  ext::shared_ptr< Fdm1DimSolver > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Fdm1DimSolver > *)jarg1;
  arg1 = (Fdm1DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmBackwardSolver(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< FdmLinearOpComposite > *arg1 = 0 ;
  FdmBoundaryConditionSet *arg2 = 0 ;
  ext::shared_ptr< FdmStepConditionComposite > arg3 ;
  FdmSchemeDesc *arg4 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull1 ;
  FdmBackwardSolver *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg1 : &tempnull1; 
  arg2 = (FdmBoundaryConditionSet *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmBoundaryConditionSet const & is null", 0);
    return 0;
  } 
  if (jarg3) arg3 = *(ext::shared_ptr< FdmStepConditionComposite > *)jarg3; 
  arg4 = (FdmSchemeDesc *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmBackwardSolver *)new FdmBackwardSolver((ext::shared_ptr< FdmLinearOpComposite > const &)*arg1,(FdmBoundaryConditionSet const &)*arg2,arg3,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdmBackwardSolver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FdmBackwardSolver_rollback(void * jarg1, void * jarg2, double jarg3, double jarg4, unsigned long jarg5, unsigned long jarg6) {
  FdmBackwardSolver *arg1 = (FdmBackwardSolver *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Time arg4 ;
  Size arg5 ;
  Size arg6 ;
  ext::shared_ptr< FdmBackwardSolver > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmBackwardSolver > *)jarg1;
  arg1 = (FdmBackwardSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array & is null", 0);
    return ;
  } 
  arg3 = (Time)jarg3; 
  arg4 = (Time)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      (arg1)->rollback(*arg2,arg3,arg4,arg5,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_delete_FdmBackwardSolver(void * jarg1) {
  FdmBackwardSolver *arg1 = (FdmBackwardSolver *) 0 ;
  ext::shared_ptr< FdmBackwardSolver > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmBackwardSolver > *)jarg1;
  arg1 = (FdmBackwardSolver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fdm2dBlackScholesSolver__SWIG_0(void * jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, unsigned int jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  FdmSolverDesc *arg4 = 0 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  Real arg7 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  Fdm2dBlackScholesSolver *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = (FdmSolverDesc *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (Fdm2dBlackScholesSolver *)new_Fdm2dBlackScholesSolver__SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,(FdmSolverDesc const &)*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 = result ? new ext::shared_ptr<  Fdm2dBlackScholesSolver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fdm2dBlackScholesSolver__SWIG_1(void * jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5, unsigned int jarg6) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  FdmSolverDesc *arg4 = 0 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  Fdm2dBlackScholesSolver *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = (FdmSolverDesc *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? true : false; 
  {
    try {
      result = (Fdm2dBlackScholesSolver *)new_Fdm2dBlackScholesSolver__SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,(FdmSolverDesc const &)*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 = result ? new ext::shared_ptr<  Fdm2dBlackScholesSolver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fdm2dBlackScholesSolver__SWIG_2(void * jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  FdmSolverDesc *arg4 = 0 ;
  FdmSchemeDesc *arg5 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  Fdm2dBlackScholesSolver *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = (FdmSolverDesc *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Fdm2dBlackScholesSolver *)new_Fdm2dBlackScholesSolver__SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,(FdmSolverDesc const &)*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 = result ? new ext::shared_ptr<  Fdm2dBlackScholesSolver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fdm2dBlackScholesSolver__SWIG_3(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  FdmSolverDesc *arg4 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull2 ;
  Fdm2dBlackScholesSolver *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  arg4 = (FdmSolverDesc *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Fdm2dBlackScholesSolver *)new_Fdm2dBlackScholesSolver__SWIG_0((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,(FdmSolverDesc 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 ? new ext::shared_ptr<  Fdm2dBlackScholesSolver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Fdm2dBlackScholesSolver_valueAt(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Fdm2dBlackScholesSolver *arg1 = (Fdm2dBlackScholesSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm2dBlackScholesSolver > *)jarg1;
  arg1 = (Fdm2dBlackScholesSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((Fdm2dBlackScholesSolver const *)arg1)->valueAt(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_Fdm2dBlackScholesSolver_thetaAt(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Fdm2dBlackScholesSolver *arg1 = (Fdm2dBlackScholesSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm2dBlackScholesSolver > *)jarg1;
  arg1 = (Fdm2dBlackScholesSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((Fdm2dBlackScholesSolver const *)arg1)->thetaAt(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_Fdm2dBlackScholesSolver_deltaXat(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Fdm2dBlackScholesSolver *arg1 = (Fdm2dBlackScholesSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm2dBlackScholesSolver > *)jarg1;
  arg1 = (Fdm2dBlackScholesSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((Fdm2dBlackScholesSolver const *)arg1)->deltaXat(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_Fdm2dBlackScholesSolver_deltaYat(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Fdm2dBlackScholesSolver *arg1 = (Fdm2dBlackScholesSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm2dBlackScholesSolver > *)jarg1;
  arg1 = (Fdm2dBlackScholesSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((Fdm2dBlackScholesSolver const *)arg1)->deltaYat(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_Fdm2dBlackScholesSolver_gammaXat(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Fdm2dBlackScholesSolver *arg1 = (Fdm2dBlackScholesSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm2dBlackScholesSolver > *)jarg1;
  arg1 = (Fdm2dBlackScholesSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((Fdm2dBlackScholesSolver const *)arg1)->gammaXat(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_Fdm2dBlackScholesSolver_gammaYat(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Fdm2dBlackScholesSolver *arg1 = (Fdm2dBlackScholesSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm2dBlackScholesSolver > *)jarg1;
  arg1 = (Fdm2dBlackScholesSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((Fdm2dBlackScholesSolver const *)arg1)->gammaYat(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_Fdm2dBlackScholesSolver_gammaXYat(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Fdm2dBlackScholesSolver *arg1 = (Fdm2dBlackScholesSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm2dBlackScholesSolver > *)jarg1;
  arg1 = (Fdm2dBlackScholesSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((Fdm2dBlackScholesSolver const *)arg1)->gammaXYat(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_Fdm2dBlackScholesSolver(void * jarg1) {
  Fdm2dBlackScholesSolver *arg1 = (Fdm2dBlackScholesSolver *) 0 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Fdm2dBlackScholesSolver > *)jarg1;
  arg1 = (Fdm2dBlackScholesSolver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fdm2DimSolver(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  FdmSolverDesc *arg1 = 0 ;
  FdmSchemeDesc *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull3 ;
  Fdm2DimSolver *result = 0 ;
  
  arg1 = (FdmSolverDesc *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  arg2 = (FdmSchemeDesc *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg3 : &tempnull3; 
  {
    try {
      result = (Fdm2DimSolver *)new Fdm2DimSolver((FdmSolverDesc const &)*arg1,(FdmSchemeDesc const &)*arg2,(ext::shared_ptr< FdmLinearOpComposite > 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 ? new ext::shared_ptr<  Fdm2DimSolver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Fdm2DimSolver_interpolateAt(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Fdm2DimSolver *arg1 = (Fdm2DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< Fdm2DimSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm2DimSolver > *)jarg1;
  arg1 = (Fdm2DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((Fdm2DimSolver const *)arg1)->interpolateAt(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_Fdm2DimSolver_thetaAt(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Fdm2DimSolver *arg1 = (Fdm2DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< Fdm2DimSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm2DimSolver > *)jarg1;
  arg1 = (Fdm2DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((Fdm2DimSolver const *)arg1)->thetaAt(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_Fdm2DimSolver_derivativeX(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Fdm2DimSolver *arg1 = (Fdm2DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< Fdm2DimSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm2DimSolver > *)jarg1;
  arg1 = (Fdm2DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((Fdm2DimSolver const *)arg1)->derivativeX(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_Fdm2DimSolver_derivativeY(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Fdm2DimSolver *arg1 = (Fdm2DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< Fdm2DimSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm2DimSolver > *)jarg1;
  arg1 = (Fdm2DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((Fdm2DimSolver const *)arg1)->derivativeY(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_Fdm2DimSolver_derivativeXX(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Fdm2DimSolver *arg1 = (Fdm2DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< Fdm2DimSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm2DimSolver > *)jarg1;
  arg1 = (Fdm2DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((Fdm2DimSolver const *)arg1)->derivativeXX(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_Fdm2DimSolver_derivativeYY(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Fdm2DimSolver *arg1 = (Fdm2DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< Fdm2DimSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm2DimSolver > *)jarg1;
  arg1 = (Fdm2DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((Fdm2DimSolver const *)arg1)->derivativeYY(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_Fdm2DimSolver_derivativeXY(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  Fdm2DimSolver *arg1 = (Fdm2DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< Fdm2DimSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm2DimSolver > *)jarg1;
  arg1 = (Fdm2DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((Fdm2DimSolver const *)arg1)->derivativeXY(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_Fdm2DimSolver(void * jarg1) {
  Fdm2DimSolver *arg1 = (Fdm2DimSolver *) 0 ;
  ext::shared_ptr< Fdm2DimSolver > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Fdm2DimSolver > *)jarg1;
  arg1 = (Fdm2DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fdm3DimSolver(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  FdmSolverDesc *arg1 = 0 ;
  FdmSchemeDesc *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull3 ;
  Fdm3DimSolver *result = 0 ;
  
  arg1 = (FdmSolverDesc *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  arg2 = (FdmSchemeDesc *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg3 : &tempnull3; 
  {
    try {
      result = (Fdm3DimSolver *)new Fdm3DimSolver((FdmSolverDesc const &)*arg1,(FdmSchemeDesc const &)*arg2,(ext::shared_ptr< FdmLinearOpComposite > 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 ? new ext::shared_ptr<  Fdm3DimSolver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Fdm3DimSolver_performCalculations(void * jarg1) {
  Fdm3DimSolver *arg1 = (Fdm3DimSolver *) 0 ;
  ext::shared_ptr< Fdm3DimSolver const > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm3DimSolver > *)jarg1;
  arg1 = (Fdm3DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      ((Fdm3DimSolver const *)arg1)->performCalculations();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_Fdm3DimSolver_interpolateAt(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  Fdm3DimSolver *arg1 = (Fdm3DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Rate arg4 ;
  ext::shared_ptr< Fdm3DimSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm3DimSolver > *)jarg1;
  arg1 = (Fdm3DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Real)((Fdm3DimSolver const *)arg1)->interpolateAt(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_Fdm3DimSolver_thetaAt(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  Fdm3DimSolver *arg1 = (Fdm3DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Rate arg4 ;
  ext::shared_ptr< Fdm3DimSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Fdm3DimSolver > *)jarg1;
  arg1 = (Fdm3DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Real)((Fdm3DimSolver const *)arg1)->thetaAt(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_Fdm3DimSolver(void * jarg1) {
  Fdm3DimSolver *arg1 = (Fdm3DimSolver *) 0 ;
  ext::shared_ptr< Fdm3DimSolver > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Fdm3DimSolver > *)jarg1;
  arg1 = (Fdm3DimSolver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmG2Solver__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  FdmSolverDesc *arg2 = 0 ;
  FdmSchemeDesc *arg3 = 0 ;
  ext::shared_ptr< G2 > tempnull1 ;
  FdmG2Solver *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< G2 > *)jarg1 : &tempnull1; 
  arg2 = (FdmSolverDesc *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  arg3 = (FdmSchemeDesc *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmG2Solver *)new_FdmG2Solver__SWIG_0((ext::shared_ptr< G2 > const &)*arg1,(FdmSolverDesc const &)*arg2,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdmG2Solver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmG2Solver__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  FdmSolverDesc *arg2 = 0 ;
  ext::shared_ptr< G2 > tempnull1 ;
  FdmG2Solver *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< G2 > *)jarg1 : &tempnull1; 
  arg2 = (FdmSolverDesc *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmG2Solver *)new_FdmG2Solver__SWIG_0((ext::shared_ptr< G2 > const &)*arg1,(FdmSolverDesc const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdmG2Solver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FdmG2Solver_valueAt(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  FdmG2Solver *arg1 = (FdmG2Solver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< FdmG2Solver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmG2Solver > *)jarg1;
  arg1 = (FdmG2Solver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((FdmG2Solver const *)arg1)->valueAt(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_FdmG2Solver(void * jarg1) {
  FdmG2Solver *arg1 = (FdmG2Solver *) 0 ;
  ext::shared_ptr< FdmG2Solver > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmG2Solver > *)jarg1;
  arg1 = (FdmG2Solver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonHullWhiteSolver__SWIG_0(void * jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > *arg2 = 0 ;
  Rate arg3 ;
  FdmSolverDesc *arg4 = 0 ;
  FdmSchemeDesc *arg5 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  ext::shared_ptr< HullWhiteProcess > tempnull2 ;
  FdmHestonHullWhiteSolver *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HullWhiteProcess > *)jarg2 : &tempnull2; 
  arg3 = (Rate)jarg3; 
  arg4 = (FdmSolverDesc *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  arg5 = (FdmSchemeDesc *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmHestonHullWhiteSolver *)new_FdmHestonHullWhiteSolver__SWIG_0((ext::shared_ptr< HestonProcess > const &)*arg1,(ext::shared_ptr< HullWhiteProcess > const &)*arg2,arg3,(FdmSolverDesc const &)*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 = result ? new ext::shared_ptr<  FdmHestonHullWhiteSolver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonHullWhiteSolver__SWIG_1(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > *arg2 = 0 ;
  Rate arg3 ;
  FdmSolverDesc *arg4 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  ext::shared_ptr< HullWhiteProcess > tempnull2 ;
  FdmHestonHullWhiteSolver *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HullWhiteProcess > *)jarg2 : &tempnull2; 
  arg3 = (Rate)jarg3; 
  arg4 = (FdmSolverDesc *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmHestonHullWhiteSolver *)new_FdmHestonHullWhiteSolver__SWIG_0((ext::shared_ptr< HestonProcess > const &)*arg1,(ext::shared_ptr< HullWhiteProcess > const &)*arg2,arg3,(FdmSolverDesc 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 ? new ext::shared_ptr<  FdmHestonHullWhiteSolver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FdmHestonHullWhiteSolver_valueAt(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  FdmHestonHullWhiteSolver *arg1 = (FdmHestonHullWhiteSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Rate arg4 ;
  ext::shared_ptr< FdmHestonHullWhiteSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmHestonHullWhiteSolver > *)jarg1;
  arg1 = (FdmHestonHullWhiteSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Real)((FdmHestonHullWhiteSolver const *)arg1)->valueAt(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_FdmHestonHullWhiteSolver_thetaAt(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  FdmHestonHullWhiteSolver *arg1 = (FdmHestonHullWhiteSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Rate arg4 ;
  ext::shared_ptr< FdmHestonHullWhiteSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmHestonHullWhiteSolver > *)jarg1;
  arg1 = (FdmHestonHullWhiteSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Rate)jarg4; 
  {
    try {
      result = (Real)((FdmHestonHullWhiteSolver const *)arg1)->thetaAt(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_FdmHestonHullWhiteSolver_deltaAt(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  FdmHestonHullWhiteSolver *arg1 = (FdmHestonHullWhiteSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Rate arg4 ;
  Real arg5 ;
  ext::shared_ptr< FdmHestonHullWhiteSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmHestonHullWhiteSolver > *)jarg1;
  arg1 = (FdmHestonHullWhiteSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)((FdmHestonHullWhiteSolver const *)arg1)->deltaAt(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_FdmHestonHullWhiteSolver_gammaAt(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  FdmHestonHullWhiteSolver *arg1 = (FdmHestonHullWhiteSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Rate arg4 ;
  Real arg5 ;
  ext::shared_ptr< FdmHestonHullWhiteSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmHestonHullWhiteSolver > *)jarg1;
  arg1 = (FdmHestonHullWhiteSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)((FdmHestonHullWhiteSolver const *)arg1)->gammaAt(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_FdmHestonHullWhiteSolver(void * jarg1) {
  FdmHestonHullWhiteSolver *arg1 = (FdmHestonHullWhiteSolver *) 0 ;
  ext::shared_ptr< FdmHestonHullWhiteSolver > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmHestonHullWhiteSolver > *)jarg1;
  arg1 = (FdmHestonHullWhiteSolver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonSolver__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  FdmSolverDesc *arg2 = 0 ;
  FdmSchemeDesc *arg3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg4 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg5 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull4 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull5 ;
  FdmHestonSolver *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (FdmSolverDesc *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  arg3 = (FdmSchemeDesc *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg4 : &tempnull4; 
  arg5 = jarg5 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg5 : &tempnull5; 
  {
    try {
      result = (FdmHestonSolver *)new_FdmHestonSolver__SWIG_0((ext::shared_ptr< HestonProcess > const &)*arg1,(FdmSolverDesc const &)*arg2,(FdmSchemeDesc const &)*arg3,(ext::shared_ptr< FdmQuantoHelper > const &)*arg4,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  FdmHestonSolver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonSolver__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  FdmSolverDesc *arg2 = 0 ;
  FdmSchemeDesc *arg3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg4 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  ext::shared_ptr< FdmQuantoHelper > tempnull4 ;
  FdmHestonSolver *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (FdmSolverDesc *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  arg3 = (FdmSchemeDesc *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (ext::shared_ptr< FdmQuantoHelper > *)jarg4 : &tempnull4; 
  {
    try {
      result = (FdmHestonSolver *)new_FdmHestonSolver__SWIG_0((ext::shared_ptr< HestonProcess > const &)*arg1,(FdmSolverDesc const &)*arg2,(FdmSchemeDesc const &)*arg3,(ext::shared_ptr< FdmQuantoHelper > 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 ? new ext::shared_ptr<  FdmHestonSolver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonSolver__SWIG_2(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  FdmSolverDesc *arg2 = 0 ;
  FdmSchemeDesc *arg3 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  FdmHestonSolver *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (FdmSolverDesc *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  arg3 = (FdmSchemeDesc *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmHestonSolver *)new_FdmHestonSolver__SWIG_0((ext::shared_ptr< HestonProcess > const &)*arg1,(FdmSolverDesc const &)*arg2,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdmHestonSolver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHestonSolver__SWIG_3(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  FdmSolverDesc *arg2 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  FdmHestonSolver *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (FdmSolverDesc *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmHestonSolver *)new_FdmHestonSolver__SWIG_0((ext::shared_ptr< HestonProcess > const &)*arg1,(FdmSolverDesc const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdmHestonSolver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FdmHestonSolver_valueAt(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  FdmHestonSolver *arg1 = (FdmHestonSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< FdmHestonSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmHestonSolver > *)jarg1;
  arg1 = (FdmHestonSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((FdmHestonSolver const *)arg1)->valueAt(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_FdmHestonSolver_thetaAt(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  FdmHestonSolver *arg1 = (FdmHestonSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< FdmHestonSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmHestonSolver > *)jarg1;
  arg1 = (FdmHestonSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((FdmHestonSolver const *)arg1)->thetaAt(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_FdmHestonSolver_deltaAt(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  FdmHestonSolver *arg1 = (FdmHestonSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< FdmHestonSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmHestonSolver > *)jarg1;
  arg1 = (FdmHestonSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((FdmHestonSolver const *)arg1)->deltaAt(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_FdmHestonSolver_gammaAt(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  FdmHestonSolver *arg1 = (FdmHestonSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< FdmHestonSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmHestonSolver > *)jarg1;
  arg1 = (FdmHestonSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((FdmHestonSolver const *)arg1)->gammaAt(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_FdmHestonSolver_meanVarianceDeltaAt(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  FdmHestonSolver *arg1 = (FdmHestonSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< FdmHestonSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmHestonSolver > *)jarg1;
  arg1 = (FdmHestonSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((FdmHestonSolver const *)arg1)->meanVarianceDeltaAt(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_FdmHestonSolver_meanVarianceGammaAt(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  FdmHestonSolver *arg1 = (FdmHestonSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< FdmHestonSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmHestonSolver > *)jarg1;
  arg1 = (FdmHestonSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((FdmHestonSolver const *)arg1)->meanVarianceGammaAt(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_FdmHestonSolver(void * jarg1) {
  FdmHestonSolver *arg1 = (FdmHestonSolver *) 0 ;
  ext::shared_ptr< FdmHestonSolver > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmHestonSolver > *)jarg1;
  arg1 = (FdmHestonSolver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHullWhiteSolver__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  FdmSolverDesc *arg2 = 0 ;
  FdmSchemeDesc *arg3 = 0 ;
  ext::shared_ptr< HullWhite > tempnull1 ;
  FdmHullWhiteSolver *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HullWhite > *)jarg1 : &tempnull1; 
  arg2 = (FdmSolverDesc *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  arg3 = (FdmSchemeDesc *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmHullWhiteSolver *)new_FdmHullWhiteSolver__SWIG_0((ext::shared_ptr< HullWhite > const &)*arg1,(FdmSolverDesc const &)*arg2,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdmHullWhiteSolver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmHullWhiteSolver__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  FdmSolverDesc *arg2 = 0 ;
  ext::shared_ptr< HullWhite > tempnull1 ;
  FdmHullWhiteSolver *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HullWhite > *)jarg1 : &tempnull1; 
  arg2 = (FdmSolverDesc *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdmHullWhiteSolver *)new_FdmHullWhiteSolver__SWIG_0((ext::shared_ptr< HullWhite > const &)*arg1,(FdmSolverDesc const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdmHullWhiteSolver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FdmHullWhiteSolver_valueAt(void * jarg1, double jarg2) {
  double jresult ;
  FdmHullWhiteSolver *arg1 = (FdmHullWhiteSolver *) 0 ;
  Real arg2 ;
  ext::shared_ptr< FdmHullWhiteSolver const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmHullWhiteSolver > *)jarg1;
  arg1 = (FdmHullWhiteSolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((FdmHullWhiteSolver const *)arg1)->valueAt(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_FdmHullWhiteSolver(void * jarg1) {
  FdmHullWhiteSolver *arg1 = (FdmHullWhiteSolver *) 0 ;
  ext::shared_ptr< FdmHullWhiteSolver > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmHullWhiteSolver > *)jarg1;
  arg1 = (FdmHullWhiteSolver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fdm4dimSolver(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  FdmSolverDesc *arg1 = 0 ;
  FdmSchemeDesc *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull3 ;
  FdmNdimSolver< 4 > *result = 0 ;
  
  arg1 = (FdmSolverDesc *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  arg2 = (FdmSchemeDesc *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg3 : &tempnull3; 
  {
    try {
      result = (FdmNdimSolver< 4 > *)new FdmNdimSolver< 4 >((FdmSolverDesc const &)*arg1,(FdmSchemeDesc const &)*arg2,(ext::shared_ptr< FdmLinearOpComposite > 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 ? new ext::shared_ptr<  FdmNdimSolver<4> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Fdm4dimSolver_interpolateAt(void * jarg1, void * jarg2) {
  double jresult ;
  FdmNdimSolver< 4 > *arg1 = (FdmNdimSolver< 4 > *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  ext::shared_ptr< FdmNdimSolver< 4 > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmNdimSolver<4> > *)jarg1;
  arg1 = (FdmNdimSolver<4> *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((FdmNdimSolver< 4 > const *)arg1)->interpolateAt((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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Fdm4dimSolver_thetaAt(void * jarg1, void * jarg2) {
  double jresult ;
  FdmNdimSolver< 4 > *arg1 = (FdmNdimSolver< 4 > *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  ext::shared_ptr< FdmNdimSolver< 4 > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmNdimSolver<4> > *)jarg1;
  arg1 = (FdmNdimSolver<4> *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((FdmNdimSolver< 4 > const *)arg1)->thetaAt((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 = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Fdm4dimSolver(void * jarg1) {
  FdmNdimSolver< 4 > *arg1 = (FdmNdimSolver< 4 > *) 0 ;
  ext::shared_ptr< FdmNdimSolver< 4 > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmNdimSolver<4> > *)jarg1;
  arg1 = (FdmNdimSolver<4> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fdm5dimSolver(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  FdmSolverDesc *arg1 = 0 ;
  FdmSchemeDesc *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull3 ;
  FdmNdimSolver< 5 > *result = 0 ;
  
  arg1 = (FdmSolverDesc *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  arg2 = (FdmSchemeDesc *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg3 : &tempnull3; 
  {
    try {
      result = (FdmNdimSolver< 5 > *)new FdmNdimSolver< 5 >((FdmSolverDesc const &)*arg1,(FdmSchemeDesc const &)*arg2,(ext::shared_ptr< FdmLinearOpComposite > 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 ? new ext::shared_ptr<  FdmNdimSolver<5> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Fdm5dimSolver_interpolateAt(void * jarg1, void * jarg2) {
  double jresult ;
  FdmNdimSolver< 5 > *arg1 = (FdmNdimSolver< 5 > *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  ext::shared_ptr< FdmNdimSolver< 5 > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmNdimSolver<5> > *)jarg1;
  arg1 = (FdmNdimSolver<5> *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((FdmNdimSolver< 5 > const *)arg1)->interpolateAt((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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Fdm5dimSolver_thetaAt(void * jarg1, void * jarg2) {
  double jresult ;
  FdmNdimSolver< 5 > *arg1 = (FdmNdimSolver< 5 > *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  ext::shared_ptr< FdmNdimSolver< 5 > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmNdimSolver<5> > *)jarg1;
  arg1 = (FdmNdimSolver<5> *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((FdmNdimSolver< 5 > const *)arg1)->thetaAt((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 = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Fdm5dimSolver(void * jarg1) {
  FdmNdimSolver< 5 > *arg1 = (FdmNdimSolver< 5 > *) 0 ;
  ext::shared_ptr< FdmNdimSolver< 5 > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmNdimSolver<5> > *)jarg1;
  arg1 = (FdmNdimSolver<5> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Fdm6dimSolver(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  FdmSolverDesc *arg1 = 0 ;
  FdmSchemeDesc *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempnull3 ;
  FdmNdimSolver< 6 > *result = 0 ;
  
  arg1 = (FdmSolverDesc *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSolverDesc const & is null", 0);
    return 0;
  } 
  arg2 = (FdmSchemeDesc *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? (ext::shared_ptr< FdmLinearOpComposite > *)jarg3 : &tempnull3; 
  {
    try {
      result = (FdmNdimSolver< 6 > *)new FdmNdimSolver< 6 >((FdmSolverDesc const &)*arg1,(FdmSchemeDesc const &)*arg2,(ext::shared_ptr< FdmLinearOpComposite > 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 ? new ext::shared_ptr<  FdmNdimSolver<6> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Fdm6dimSolver_interpolateAt(void * jarg1, void * jarg2) {
  double jresult ;
  FdmNdimSolver< 6 > *arg1 = (FdmNdimSolver< 6 > *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  ext::shared_ptr< FdmNdimSolver< 6 > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmNdimSolver<6> > *)jarg1;
  arg1 = (FdmNdimSolver<6> *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((FdmNdimSolver< 6 > const *)arg1)->interpolateAt((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 = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Fdm6dimSolver_thetaAt(void * jarg1, void * jarg2) {
  double jresult ;
  FdmNdimSolver< 6 > *arg1 = (FdmNdimSolver< 6 > *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  ext::shared_ptr< FdmNdimSolver< 6 > const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmNdimSolver<6> > *)jarg1;
  arg1 = (FdmNdimSolver<6> *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((FdmNdimSolver< 6 > const *)arg1)->thetaAt((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 = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Fdm6dimSolver(void * jarg1) {
  FdmNdimSolver< 6 > *arg1 = (FdmNdimSolver< 6 > *) 0 ;
  ext::shared_ptr< FdmNdimSolver< 6 > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmNdimSolver<6> > *)jarg1;
  arg1 = (FdmNdimSolver<6> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdmIndicesOnBoundary(void * jarg1, unsigned long jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< FdmLinearOpLayout > *arg1 = 0 ;
  Size arg2 ;
  FdmDirichletBoundary::Side arg3 ;
  ext::shared_ptr< FdmLinearOpLayout > tempnull1 ;
  FdmIndicesOnBoundary *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FdmLinearOpLayout > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (FdmDirichletBoundary::Side)jarg3; 
  {
    try {
      result = (FdmIndicesOnBoundary *)new FdmIndicesOnBoundary((ext::shared_ptr< FdmLinearOpLayout > 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 ? new ext::shared_ptr<  FdmIndicesOnBoundary >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FdmIndicesOnBoundary_getIndices(void * jarg1) {
  void * jresult ;
  FdmIndicesOnBoundary *arg1 = (FdmIndicesOnBoundary *) 0 ;
  ext::shared_ptr< FdmIndicesOnBoundary const > *smartarg1 = 0 ;
  std::vector< unsigned int > result;
  
  
  smartarg1 = (ext::shared_ptr< const FdmIndicesOnBoundary > *)jarg1;
  arg1 = (FdmIndicesOnBoundary *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = FdmIndicesOnBoundary_getIndices((FdmIndicesOnBoundary const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdmIndicesOnBoundary(void * jarg1) {
  FdmIndicesOnBoundary *arg1 = (FdmIndicesOnBoundary *) 0 ;
  ext::shared_ptr< FdmIndicesOnBoundary > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdmIndicesOnBoundary > *)jarg1;
  arg1 = (FdmIndicesOnBoundary *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_RiskNeutralDensityCalculator_pdf(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  RiskNeutralDensityCalculator *arg1 = (RiskNeutralDensityCalculator *) 0 ;
  Real arg2 ;
  Time arg3 ;
  ext::shared_ptr< RiskNeutralDensityCalculator const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const RiskNeutralDensityCalculator > *)jarg1;
  arg1 = (RiskNeutralDensityCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)((RiskNeutralDensityCalculator const *)arg1)->pdf(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_RiskNeutralDensityCalculator_cdf(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  RiskNeutralDensityCalculator *arg1 = (RiskNeutralDensityCalculator *) 0 ;
  Real arg2 ;
  Time arg3 ;
  ext::shared_ptr< RiskNeutralDensityCalculator const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const RiskNeutralDensityCalculator > *)jarg1;
  arg1 = (RiskNeutralDensityCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)((RiskNeutralDensityCalculator const *)arg1)->cdf(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_RiskNeutralDensityCalculator_invcdf(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  RiskNeutralDensityCalculator *arg1 = (RiskNeutralDensityCalculator *) 0 ;
  Real arg2 ;
  Time arg3 ;
  ext::shared_ptr< RiskNeutralDensityCalculator const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const RiskNeutralDensityCalculator > *)jarg1;
  arg1 = (RiskNeutralDensityCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)((RiskNeutralDensityCalculator const *)arg1)->invcdf(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_RiskNeutralDensityCalculator(void * jarg1) {
  RiskNeutralDensityCalculator *arg1 = (RiskNeutralDensityCalculator *) 0 ;
  ext::shared_ptr< RiskNeutralDensityCalculator > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  RiskNeutralDensityCalculator > *)jarg1;
  arg1 = (RiskNeutralDensityCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_BSMRNDCalculator(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  BSMRNDCalculator *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (BSMRNDCalculator *)new BSMRNDCalculator((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  BSMRNDCalculator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BSMRNDCalculator(void * jarg1) {
  BSMRNDCalculator *arg1 = (BSMRNDCalculator *) 0 ;
  ext::shared_ptr< BSMRNDCalculator > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BSMRNDCalculator > *)jarg1;
  arg1 = (BSMRNDCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CEVRNDCalculator(double jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  CEVRNDCalculator *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (CEVRNDCalculator *)new CEVRNDCalculator(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 ? new ext::shared_ptr<  CEVRNDCalculator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CEVRNDCalculator_massAtZero(void * jarg1, double jarg2) {
  double jresult ;
  CEVRNDCalculator *arg1 = (CEVRNDCalculator *) 0 ;
  Time arg2 ;
  ext::shared_ptr< CEVRNDCalculator const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const CEVRNDCalculator > *)jarg1;
  arg1 = (CEVRNDCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)((CEVRNDCalculator const *)arg1)->massAtZero(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_CEVRNDCalculator(void * jarg1) {
  CEVRNDCalculator *arg1 = (CEVRNDCalculator *) 0 ;
  ext::shared_ptr< CEVRNDCalculator > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CEVRNDCalculator > *)jarg1;
  arg1 = (CEVRNDCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GBSMRNDCalculator(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  GBSMRNDCalculator *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (GBSMRNDCalculator *)new GBSMRNDCalculator((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  GBSMRNDCalculator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GBSMRNDCalculator(void * jarg1) {
  GBSMRNDCalculator *arg1 = (GBSMRNDCalculator *) 0 ;
  ext::shared_ptr< GBSMRNDCalculator > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GBSMRNDCalculator > *)jarg1;
  arg1 = (GBSMRNDCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HestonRNDCalculator__SWIG_0(void * jarg1, double jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  HestonRNDCalculator *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (HestonRNDCalculator *)new HestonRNDCalculator((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  HestonRNDCalculator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HestonRNDCalculator__SWIG_1(void * jarg1, double jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  HestonRNDCalculator *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (HestonRNDCalculator *)new HestonRNDCalculator((ext::shared_ptr< HestonProcess > 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 ? new ext::shared_ptr<  HestonRNDCalculator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HestonRNDCalculator__SWIG_2(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  HestonRNDCalculator *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (HestonRNDCalculator *)new HestonRNDCalculator((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  HestonRNDCalculator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HestonRNDCalculator(void * jarg1) {
  HestonRNDCalculator *arg1 = (HestonRNDCalculator *) 0 ;
  ext::shared_ptr< HestonRNDCalculator > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  HestonRNDCalculator > *)jarg1;
  arg1 = (HestonRNDCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalVolRNDCalculator__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5, unsigned long jarg6, double jarg7, double jarg8, unsigned long jarg9, double jarg10) {
  void * jresult ;
  ext::shared_ptr< Quote > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Real arg7 ;
  Real arg8 ;
  Size arg9 ;
  Time arg10 ;
  ext::shared_ptr< Quote > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull4 ;
  LocalVolRNDCalculator *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Quote > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg4 : &tempnull4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Size)jarg9; 
  arg10 = (Time)jarg10; 
  {
    try {
      result = (LocalVolRNDCalculator *)new LocalVolRNDCalculator((ext::shared_ptr< Quote > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  LocalVolRNDCalculator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalVolRNDCalculator__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5, unsigned long jarg6, double jarg7, double jarg8, unsigned long jarg9) {
  void * jresult ;
  ext::shared_ptr< Quote > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Real arg7 ;
  Real arg8 ;
  Size arg9 ;
  ext::shared_ptr< Quote > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull4 ;
  LocalVolRNDCalculator *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Quote > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg4 : &tempnull4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Size)jarg9; 
  {
    try {
      result = (LocalVolRNDCalculator *)new LocalVolRNDCalculator((ext::shared_ptr< Quote > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  LocalVolRNDCalculator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalVolRNDCalculator__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5, unsigned long jarg6, double jarg7, double jarg8) {
  void * jresult ;
  ext::shared_ptr< Quote > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Real arg7 ;
  Real arg8 ;
  ext::shared_ptr< Quote > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull4 ;
  LocalVolRNDCalculator *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Quote > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg4 : &tempnull4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (LocalVolRNDCalculator *)new LocalVolRNDCalculator((ext::shared_ptr< Quote > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  LocalVolRNDCalculator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalVolRNDCalculator__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5, unsigned long jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< Quote > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Real arg7 ;
  ext::shared_ptr< Quote > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull4 ;
  LocalVolRNDCalculator *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Quote > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg4 : &tempnull4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (LocalVolRNDCalculator *)new LocalVolRNDCalculator((ext::shared_ptr< Quote > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  LocalVolRNDCalculator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalVolRNDCalculator__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< Quote > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  ext::shared_ptr< Quote > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull4 ;
  LocalVolRNDCalculator *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Quote > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg4 : &tempnull4; 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (LocalVolRNDCalculator *)new LocalVolRNDCalculator((ext::shared_ptr< Quote > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  LocalVolRNDCalculator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalVolRNDCalculator__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< Quote > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg4 = 0 ;
  Size arg5 ;
  ext::shared_ptr< Quote > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull4 ;
  LocalVolRNDCalculator *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Quote > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg4 : &tempnull4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (LocalVolRNDCalculator *)new LocalVolRNDCalculator((ext::shared_ptr< Quote > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  LocalVolRNDCalculator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LocalVolRNDCalculator__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< Quote > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg4 = 0 ;
  ext::shared_ptr< Quote > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  ext::shared_ptr< YieldTermStructure > tempnull3 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull4 ;
  LocalVolRNDCalculator *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Quote > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< YieldTermStructure > *)jarg3 : &tempnull3; 
  arg4 = jarg4 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg4 : &tempnull4; 
  {
    try {
      result = (LocalVolRNDCalculator *)new LocalVolRNDCalculator((ext::shared_ptr< Quote > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  LocalVolRNDCalculator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LocalVolRNDCalculator_mesher(void * jarg1, double jarg2) {
  void * jresult ;
  LocalVolRNDCalculator *arg1 = (LocalVolRNDCalculator *) 0 ;
  Time arg2 ;
  ext::shared_ptr< LocalVolRNDCalculator const > *smartarg1 = 0 ;
  ext::shared_ptr< Fdm1dMesher > result;
  
  
  smartarg1 = (ext::shared_ptr< const LocalVolRNDCalculator > *)jarg1;
  arg1 = (LocalVolRNDCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = ((LocalVolRNDCalculator const *)arg1)->mesher(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< Fdm1dMesher >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LocalVolRNDCalculator_rescaleTimeSteps(void * jarg1) {
  void * jresult ;
  LocalVolRNDCalculator *arg1 = (LocalVolRNDCalculator *) 0 ;
  ext::shared_ptr< LocalVolRNDCalculator const > *smartarg1 = 0 ;
  std::vector< unsigned int > result;
  
  
  smartarg1 = (ext::shared_ptr< const LocalVolRNDCalculator > *)jarg1;
  arg1 = (LocalVolRNDCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = LocalVolRNDCalculator_rescaleTimeSteps((LocalVolRNDCalculator const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LocalVolRNDCalculator(void * jarg1) {
  LocalVolRNDCalculator *arg1 = (LocalVolRNDCalculator *) 0 ;
  ext::shared_ptr< LocalVolRNDCalculator > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  LocalVolRNDCalculator > *)jarg1;
  arg1 = (LocalVolRNDCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SquareRootProcessRNDCalculator(double jarg1, double jarg2, double jarg3, double jarg4) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  SquareRootProcessRNDCalculator *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (SquareRootProcessRNDCalculator *)new SquareRootProcessRNDCalculator(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 ? new ext::shared_ptr<  SquareRootProcessRNDCalculator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SquareRootProcessRNDCalculator_stationary_pdf(void * jarg1, double jarg2) {
  double jresult ;
  SquareRootProcessRNDCalculator *arg1 = (SquareRootProcessRNDCalculator *) 0 ;
  Real arg2 ;
  ext::shared_ptr< SquareRootProcessRNDCalculator const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SquareRootProcessRNDCalculator > *)jarg1;
  arg1 = (SquareRootProcessRNDCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((SquareRootProcessRNDCalculator const *)arg1)->stationary_pdf(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SquareRootProcessRNDCalculator_stationary_cdf(void * jarg1, double jarg2) {
  double jresult ;
  SquareRootProcessRNDCalculator *arg1 = (SquareRootProcessRNDCalculator *) 0 ;
  Real arg2 ;
  ext::shared_ptr< SquareRootProcessRNDCalculator const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SquareRootProcessRNDCalculator > *)jarg1;
  arg1 = (SquareRootProcessRNDCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((SquareRootProcessRNDCalculator const *)arg1)->stationary_cdf(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_SquareRootProcessRNDCalculator_stationary_invcdf(void * jarg1, double jarg2) {
  double jresult ;
  SquareRootProcessRNDCalculator *arg1 = (SquareRootProcessRNDCalculator *) 0 ;
  Real arg2 ;
  ext::shared_ptr< SquareRootProcessRNDCalculator const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const SquareRootProcessRNDCalculator > *)jarg1;
  arg1 = (SquareRootProcessRNDCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (Real)((SquareRootProcessRNDCalculator const *)arg1)->stationary_invcdf(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_SquareRootProcessRNDCalculator(void * jarg1) {
  SquareRootProcessRNDCalculator *arg1 = (SquareRootProcessRNDCalculator *) 0 ;
  ext::shared_ptr< SquareRootProcessRNDCalculator > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SquareRootProcessRNDCalculator > *)jarg1;
  arg1 = (SquareRootProcessRNDCalculator *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  ext::shared_ptr< FittingMethod > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FittingMethod > *)jarg1;
  arg1 = (FittingMethod *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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 ;
  ext::shared_ptr< FittingMethod const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const FittingMethod > *)jarg1;
  arg1 = (FittingMethod *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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 ;
  ext::shared_ptr< FittingMethod const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const FittingMethod > *)jarg1;
  arg1 = (FittingMethod *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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(result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_FittingMethod_numberOfIterations(void * jarg1) {
  int jresult ;
  FittingMethod *arg1 = (FittingMethod *) 0 ;
  ext::shared_ptr< FittingMethod const > *smartarg1 = 0 ;
  Integer result;
  
  
  smartarg1 = (ext::shared_ptr< const FittingMethod > *)jarg1;
  arg1 = (FittingMethod *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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 ;
  ext::shared_ptr< FittingMethod const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const FittingMethod > *)jarg1;
  arg1 = (FittingMethod *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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 ;
  ext::shared_ptr< FittingMethod const > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (ext::shared_ptr< const FittingMethod > *)jarg1;
  arg1 = (FittingMethod *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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 ;
  ext::shared_ptr< FittingMethod const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const FittingMethod > *)jarg1;
  arg1 = (FittingMethod *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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(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< ext::shared_ptr< BondHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FittingMethod *arg5 = 0 ;
  Real arg6 ;
  Size arg7 ;
  Array *arg8 = 0 ;
  Real arg9 ;
  FittedBondDiscountCurve *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BondHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  
  arg5 = (FittingMethod *)(((ext::shared_ptr< const FittingMethod > *)jarg5) ? ((ext::shared_ptr< const FittingMethod > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & reference is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Array *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< BondHelper > > 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 = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< BondHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FittingMethod *arg5 = 0 ;
  Real arg6 ;
  Size arg7 ;
  Array *arg8 = 0 ;
  FittedBondDiscountCurve *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BondHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  
  arg5 = (FittingMethod *)(((ext::shared_ptr< const FittingMethod > *)jarg5) ? ((ext::shared_ptr< const FittingMethod > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & reference is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Array *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< BondHelper > > 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 = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< BondHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FittingMethod *arg5 = 0 ;
  Real arg6 ;
  Size arg7 ;
  FittedBondDiscountCurve *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BondHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  
  arg5 = (FittingMethod *)(((ext::shared_ptr< const FittingMethod > *)jarg5) ? ((ext::shared_ptr< const FittingMethod > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & reference is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< BondHelper > > 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 = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< BondHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FittingMethod *arg5 = 0 ;
  Real arg6 ;
  FittedBondDiscountCurve *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BondHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  
  arg5 = (FittingMethod *)(((ext::shared_ptr< const FittingMethod > *)jarg5) ? ((ext::shared_ptr< const FittingMethod > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & reference is null", 0);
    return 0;
  } 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< BondHelper > > 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 = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< BondHelper > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FittingMethod *arg5 = 0 ;
  FittedBondDiscountCurve *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BondHelper > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  
  arg5 = (FittingMethod *)(((ext::shared_ptr< const FittingMethod > *)jarg5) ? ((ext::shared_ptr< const FittingMethod > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< BondHelper > > 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 = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< BondHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FittingMethod *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  Array *arg7 = 0 ;
  Real arg8 ;
  FittedBondDiscountCurve *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BondHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  
  arg4 = (FittingMethod *)(((ext::shared_ptr< const FittingMethod > *)jarg4) ? ((ext::shared_ptr< const FittingMethod > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & reference is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Array *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve((Date const &)*arg1,(std::vector< ext::shared_ptr< BondHelper > > 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 = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< BondHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FittingMethod *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  Array *arg7 = 0 ;
  FittedBondDiscountCurve *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BondHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  
  arg4 = (FittingMethod *)(((ext::shared_ptr< const FittingMethod > *)jarg4) ? ((ext::shared_ptr< const FittingMethod > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & reference is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Array *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve((Date const &)*arg1,(std::vector< ext::shared_ptr< BondHelper > > 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 = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< BondHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FittingMethod *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  FittedBondDiscountCurve *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BondHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  
  arg4 = (FittingMethod *)(((ext::shared_ptr< const FittingMethod > *)jarg4) ? ((ext::shared_ptr< const FittingMethod > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & reference is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve((Date const &)*arg1,(std::vector< ext::shared_ptr< BondHelper > > 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 = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< BondHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FittingMethod *arg4 = 0 ;
  Real arg5 ;
  FittedBondDiscountCurve *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BondHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  
  arg4 = (FittingMethod *)(((ext::shared_ptr< const FittingMethod > *)jarg4) ? ((ext::shared_ptr< const FittingMethod > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & reference is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve((Date const &)*arg1,(std::vector< ext::shared_ptr< BondHelper > > 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 = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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< ext::shared_ptr< BondHelper > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FittingMethod *arg4 = 0 ;
  FittedBondDiscountCurve *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< ext::shared_ptr< BondHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BondHelper > > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  
  arg4 = (FittingMethod *)(((ext::shared_ptr< const FittingMethod > *)jarg4) ? ((ext::shared_ptr< const FittingMethod > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FittingMethod const & reference is null", 0);
    return 0;
  } 
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve((Date const &)*arg1,(std::vector< ext::shared_ptr< BondHelper > > 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 = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FittedBondDiscountCurve_fitResults(void * jarg1) {
  void * jresult ;
  FittedBondDiscountCurve *arg1 = (FittedBondDiscountCurve *) 0 ;
  ext::shared_ptr< FittedBondDiscountCurve const > *smartarg1 = 0 ;
  FittingMethod *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const FittedBondDiscountCurve > *)jarg1;
  arg1 = (FittedBondDiscountCurve *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (FittingMethod *) &((FittedBondDiscountCurve const *)arg1)->fitResults();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = new ext::shared_ptr< const FittingMethod >(result SWIG_NO_NULL_DELETER_0); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FittedBondDiscountCurve(void * jarg1) {
  FittedBondDiscountCurve *arg1 = (FittedBondDiscountCurve *) 0 ;
  ext::shared_ptr< FittedBondDiscountCurve > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FittedBondDiscountCurve > *)jarg1;
  arg1 = (FittedBondDiscountCurve *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 * jarg3, double jarg4, double jarg5, unsigned long jarg6, double jarg7) {
  void * jresult ;
  bool arg1 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  Size arg6 ;
  Real arg7 ;
  ExponentialSplinesFitting *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (ExponentialSplinesFitting *)new ExponentialSplinesFitting(arg1,(Array const &)*arg2,(Array 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 ? new ext::shared_ptr<  ExponentialSplinesFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialSplinesFitting__SWIG_1(unsigned int jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5, unsigned long jarg6) {
  void * jresult ;
  bool arg1 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  Size arg6 ;
  ExponentialSplinesFitting *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (ExponentialSplinesFitting *)new ExponentialSplinesFitting(arg1,(Array const &)*arg2,(Array 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 ? new ext::shared_ptr<  ExponentialSplinesFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialSplinesFitting__SWIG_2(unsigned int jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5) {
  void * jresult ;
  bool arg1 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  ExponentialSplinesFitting *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (ExponentialSplinesFitting *)new ExponentialSplinesFitting(arg1,(Array const &)*arg2,(Array 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 ? new ext::shared_ptr<  ExponentialSplinesFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialSplinesFitting__SWIG_3(unsigned int jarg1, void * jarg2, void * jarg3, double jarg4) {
  void * jresult ;
  bool arg1 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  Real arg4 ;
  ExponentialSplinesFitting *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (ExponentialSplinesFitting *)new ExponentialSplinesFitting(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 = result ? new ext::shared_ptr<  ExponentialSplinesFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialSplinesFitting__SWIG_4(unsigned int jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  bool arg1 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  ExponentialSplinesFitting *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ExponentialSplinesFitting *)new ExponentialSplinesFitting(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 = result ? new ext::shared_ptr<  ExponentialSplinesFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialSplinesFitting__SWIG_5(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 & 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 = result ? new ext::shared_ptr<  ExponentialSplinesFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialSplinesFitting__SWIG_6(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 = result ? new ext::shared_ptr<  ExponentialSplinesFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialSplinesFitting__SWIG_7() {
  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 = result ? new ext::shared_ptr<  ExponentialSplinesFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ExponentialSplinesFitting(void * jarg1) {
  ExponentialSplinesFitting *arg1 = (ExponentialSplinesFitting *) 0 ;
  ext::shared_ptr< ExponentialSplinesFitting > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ExponentialSplinesFitting > *)jarg1;
  arg1 = (ExponentialSplinesFitting *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & 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 = result ? new ext::shared_ptr<  NelsonSiegelFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 = result ? new ext::shared_ptr<  NelsonSiegelFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NelsonSiegelFitting(void * jarg1) {
  NelsonSiegelFitting *arg1 = (NelsonSiegelFitting *) 0 ;
  ext::shared_ptr< NelsonSiegelFitting > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  NelsonSiegelFitting > *)jarg1;
  arg1 = (NelsonSiegelFitting *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & 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 = result ? new ext::shared_ptr<  SvenssonFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 = result ? new ext::shared_ptr<  SvenssonFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SvenssonFitting(void * jarg1) {
  SvenssonFitting *arg1 = (SvenssonFitting *) 0 ;
  ext::shared_ptr< SvenssonFitting > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SvenssonFitting > *)jarg1;
  arg1 = (SvenssonFitting *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 = result ? new ext::shared_ptr<  CubicBSplinesFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & 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 = result ? new ext::shared_ptr<  CubicBSplinesFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 & 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 = result ? new ext::shared_ptr<  CubicBSplinesFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< CubicBSplinesFitting > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  CubicBSplinesFitting > *)jarg1;
  arg1 = (CubicBSplinesFitting *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  ext::shared_ptr< CubicBSplinesFitting > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CubicBSplinesFitting > *)jarg1;
  arg1 = (CubicBSplinesFitting *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & 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 = result ? new ext::shared_ptr<  SimplePolynomialFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 = result ? new ext::shared_ptr<  SimplePolynomialFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 = result ? new ext::shared_ptr<  SimplePolynomialFitting >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SimplePolynomialFitting(void * jarg1) {
  SimplePolynomialFitting *arg1 = (SimplePolynomialFitting *) 0 ;
  ext::shared_ptr< SimplePolynomialFitting > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SimplePolynomialFitting > *)jarg1;
  arg1 = (SimplePolynomialFitting *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadFittingMethod__SWIG_0(void * jarg1, void * jarg2, double jarg3, double jarg4) {
  void * jresult ;
  ext::shared_ptr< FittingMethod > *arg1 = 0 ;
  Handle< YieldTermStructure > arg2 ;
  Real arg3 ;
  Real arg4 ;
  ext::shared_ptr< FittingMethod > tempnull1 ;
  Handle< YieldTermStructure > *argp2 ;
  SpreadFittingMethod *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FittingMethod > *)jarg1 : &tempnull1; 
  argp2 = (Handle< YieldTermStructure > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (SpreadFittingMethod *)new SpreadFittingMethod((ext::shared_ptr< FittingMethod > 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 ? new ext::shared_ptr<  SpreadFittingMethod >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadFittingMethod__SWIG_1(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< FittingMethod > *arg1 = 0 ;
  Handle< YieldTermStructure > arg2 ;
  Real arg3 ;
  ext::shared_ptr< FittingMethod > tempnull1 ;
  Handle< YieldTermStructure > *argp2 ;
  SpreadFittingMethod *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FittingMethod > *)jarg1 : &tempnull1; 
  argp2 = (Handle< YieldTermStructure > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (SpreadFittingMethod *)new SpreadFittingMethod((ext::shared_ptr< FittingMethod > 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 ? new ext::shared_ptr<  SpreadFittingMethod >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadFittingMethod__SWIG_2(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< FittingMethod > *arg1 = 0 ;
  Handle< YieldTermStructure > arg2 ;
  ext::shared_ptr< FittingMethod > tempnull1 ;
  Handle< YieldTermStructure > *argp2 ;
  SpreadFittingMethod *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FittingMethod > *)jarg1 : &tempnull1; 
  argp2 = (Handle< YieldTermStructure > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (SpreadFittingMethod *)new SpreadFittingMethod((ext::shared_ptr< FittingMethod > 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 ? new ext::shared_ptr<  SpreadFittingMethod >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SpreadFittingMethod(void * jarg1) {
  SpreadFittingMethod *arg1 = (SpreadFittingMethod *) 0 ;
  ext::shared_ptr< SpreadFittingMethod > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SpreadFittingMethod > *)jarg1;
  arg1 = (SpreadFittingMethod *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  InterpolatedForwardCurve< BackwardFlat > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (BackwardFlat *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BackwardFlat const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedForwardCurve< BackwardFlat > *)new InterpolatedForwardCurve< BackwardFlat >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedForwardCurve<BackwardFlat> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedForwardCurve< BackwardFlat > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedForwardCurve< BackwardFlat > *)new InterpolatedForwardCurve< BackwardFlat >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedForwardCurve<BackwardFlat> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedForwardCurve< BackwardFlat > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedForwardCurve< BackwardFlat > *)new InterpolatedForwardCurve< BackwardFlat >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedForwardCurve<BackwardFlat> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ForwardCurve_dates(void * jarg1) {
  void * jresult ;
  InterpolatedForwardCurve< BackwardFlat > *arg1 = (InterpolatedForwardCurve< BackwardFlat > *) 0 ;
  ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedForwardCurve<BackwardFlat> > *)jarg1;
  arg1 = (InterpolatedForwardCurve<BackwardFlat> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedForwardCurve< BackwardFlat > 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_ForwardCurve_forwards(void * jarg1) {
  void * jresult ;
  InterpolatedForwardCurve< BackwardFlat > *arg1 = (InterpolatedForwardCurve< BackwardFlat > *) 0 ;
  ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > const > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedForwardCurve<BackwardFlat> > *)jarg1;
  arg1 = (InterpolatedForwardCurve<BackwardFlat> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Rate > *) &((InterpolatedForwardCurve< BackwardFlat > const *)arg1)->forwards();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  InterpolatedForwardCurve< BackwardFlat > *arg1 = (InterpolatedForwardCurve< BackwardFlat > *) 0 ;
  ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedForwardCurve<BackwardFlat> > *)jarg1;
  arg1 = (InterpolatedForwardCurve<BackwardFlat> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedForwardCurve< BackwardFlat > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ForwardCurve(void * jarg1) {
  InterpolatedForwardCurve< BackwardFlat > *arg1 = (InterpolatedForwardCurve< BackwardFlat > *) 0 ;
  ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedForwardCurve<BackwardFlat> > *)jarg1;
  arg1 = (InterpolatedForwardCurve<BackwardFlat> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, unsigned int jarg8) {
  void * jresult ;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Rate arg4 ;
  Real arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  bool arg8 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  ForwardRateAgreement *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Position::Type)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardRateAgreement__SWIG_1(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 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  ForwardRateAgreement *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Position::Type)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardRateAgreement__SWIG_2(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 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  ext::shared_ptr< IborIndex > tempnull6 ;
  ForwardRateAgreement *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Position::Type)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = jarg6 ? (ext::shared_ptr< IborIndex > *)jarg6 : &tempnull6; 
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardRateAgreement__SWIG_3(void * jarg1, int jarg2, double jarg3, double jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  Position::Type arg2 ;
  Rate arg3 ;
  Real arg4 ;
  ext::shared_ptr< IborIndex > *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  ext::shared_ptr< IborIndex > tempnull5 ;
  ForwardRateAgreement *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Position::Type)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? (ext::shared_ptr< IborIndex > *)jarg5 : &tempnull5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((Date const &)*arg1,arg2,arg3,arg4,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardRateAgreement__SWIG_4(void * jarg1, int jarg2, double jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  Position::Type arg2 ;
  Rate arg3 ;
  Real arg4 ;
  ext::shared_ptr< IborIndex > *arg5 = 0 ;
  ext::shared_ptr< IborIndex > tempnull5 ;
  ForwardRateAgreement *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Position::Type)jarg2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = jarg5 ? (ext::shared_ptr< IborIndex > *)jarg5 : &tempnull5; 
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((Date const &)*arg1,arg2,arg3,arg4,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardRateAgreement__SWIG_5(void * jarg1, void * jarg2, int jarg3, double jarg4, double jarg5, void * jarg6) {
  void * jresult ;
  ext::shared_ptr< IborIndex > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Rate arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > arg6 ;
  ext::shared_ptr< IborIndex > tempnull1 ;
  Handle< YieldTermStructure > *argp6 ;
  ForwardRateAgreement *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< IborIndex > *)jarg1 : &tempnull1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Position::Type)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = (Real)jarg5; 
  argp6 = (Handle< YieldTermStructure > *)jarg6; 
  if (!argp6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg6 = *argp6; 
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((ext::shared_ptr< IborIndex > const &)*arg1,(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 = result ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardRateAgreement__SWIG_6(void * jarg1, void * jarg2, int jarg3, double jarg4, double jarg5) {
  void * jresult ;
  ext::shared_ptr< IborIndex > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Rate arg4 ;
  Real arg5 ;
  ext::shared_ptr< IborIndex > tempnull1 ;
  ForwardRateAgreement *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< IborIndex > *)jarg1 : &tempnull1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Position::Type)jarg3; 
  arg4 = (Rate)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((ext::shared_ptr< IborIndex > const &)*arg1,(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 = result ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardRateAgreement__SWIG_7(void * jarg1, void * jarg2, void * jarg3, int jarg4, double jarg5, double jarg6, void * jarg7) {
  void * jresult ;
  ext::shared_ptr< IborIndex > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Position::Type arg4 ;
  Rate arg5 ;
  Real arg6 ;
  Handle< YieldTermStructure > arg7 ;
  ext::shared_ptr< IborIndex > tempnull1 ;
  Handle< YieldTermStructure > *argp7 ;
  ForwardRateAgreement *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< IborIndex > *)jarg1 : &tempnull1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Position::Type)jarg4; 
  arg5 = (Rate)jarg5; 
  arg6 = (Real)jarg6; 
  argp7 = (Handle< YieldTermStructure > *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Handle< YieldTermStructure >", 0);
    return 0;
  }
  arg7 = *argp7; 
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((ext::shared_ptr< IborIndex > const &)*arg1,(Date const &)*arg2,(Date 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 ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ForwardRateAgreement__SWIG_8(void * jarg1, void * jarg2, void * jarg3, int jarg4, double jarg5, double jarg6) {
  void * jresult ;
  ext::shared_ptr< IborIndex > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Position::Type arg4 ;
  Rate arg5 ;
  Real arg6 ;
  ext::shared_ptr< IborIndex > tempnull1 ;
  ForwardRateAgreement *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< IborIndex > *)jarg1 : &tempnull1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Position::Type)jarg4; 
  arg5 = (Rate)jarg5; 
  arg6 = (Real)jarg6; 
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((ext::shared_ptr< IborIndex > const &)*arg1,(Date const &)*arg2,(Date 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 ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_ForwardRateAgreement_amount(void * jarg1) {
  double jresult ;
  ForwardRateAgreement *arg1 = (ForwardRateAgreement *) 0 ;
  ext::shared_ptr< ForwardRateAgreement const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const ForwardRateAgreement > *)jarg1;
  arg1 = (ForwardRateAgreement *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((ForwardRateAgreement 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 void * SWIGSTDCALL CSharp_QuantLib_ForwardRateAgreement_fixingDate(void * jarg1) {
  void * jresult ;
  ForwardRateAgreement *arg1 = (ForwardRateAgreement *) 0 ;
  ext::shared_ptr< ForwardRateAgreement const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const ForwardRateAgreement > *)jarg1;
  arg1 = (ForwardRateAgreement *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((ForwardRateAgreement const *)arg1)->fixingDate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ForwardRateAgreement_forwardRate(void * jarg1) {
  void * jresult ;
  ForwardRateAgreement *arg1 = (ForwardRateAgreement *) 0 ;
  ext::shared_ptr< ForwardRateAgreement const > *smartarg1 = 0 ;
  InterestRate result;
  
  
  smartarg1 = (ext::shared_ptr< const ForwardRateAgreement > *)jarg1;
  arg1 = (ForwardRateAgreement *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((ForwardRateAgreement const *)arg1)->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 = new InterestRate(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ForwardRateAgreement(void * jarg1) {
  ForwardRateAgreement *arg1 = (ForwardRateAgreement *) 0 ;
  ext::shared_ptr< ForwardRateAgreement > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ForwardRateAgreement > *)jarg1;
  arg1 = (ForwardRateAgreement *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  ext::shared_ptr< StochasticProcess1D > result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Gaussian1dModel const *)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 = result ? new ext::shared_ptr< StochasticProcess1D >(result) : 0; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_numeraire__SWIG_0(void * jarg1, double jarg2, double jarg3, void * jarg4) {
  double jresult ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Time arg2 ;
  Real arg3 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Time arg2 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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_zerobond__SWIG_0(void * jarg1, double jarg2, double jarg3, double jarg4, void * jarg5) {
  double jresult ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  ext::shared_ptr< Gaussian1dModel > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  ext::shared_ptr< Gaussian1dModel > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Time arg2 ;
  Time arg3 ;
  ext::shared_ptr< Gaussian1dModel > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Time arg2 ;
  ext::shared_ptr< Gaussian1dModel > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  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_numeraire__SWIG_3(void * jarg1, void * jarg2, double jarg3, void * jarg4) {
  double jresult ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  arg4 = (Handle< YieldTermStructure > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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_4(void * jarg1, void * jarg2, void * jarg3, double jarg4, void * jarg5) {
  double jresult ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Handle< YieldTermStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (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 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Option::Type temp2 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  temp2 = (Option::Type)jarg2; 
  arg2 = &temp2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Rate)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  arg9 = (Handle< YieldTermStructure > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Size)jarg11; 
  arg12 = jarg12 ? true : false; 
  arg13 = jarg13 ? true : false; 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (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 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Option::Type temp2 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  temp2 = (Option::Type)jarg2; 
  arg2 = &temp2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Rate)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  arg9 = (Handle< YieldTermStructure > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Size)jarg11; 
  arg12 = jarg12 ? true : false; 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (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 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Option::Type temp2 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  temp2 = (Option::Type)jarg2; 
  arg2 = &temp2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Rate)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  arg9 = (Handle< YieldTermStructure > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  arg11 = (Size)jarg11; 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (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 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Option::Type temp2 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  temp2 = (Option::Type)jarg2; 
  arg2 = &temp2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Rate)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  arg9 = (Handle< YieldTermStructure > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (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 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Option::Type temp2 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  temp2 = (Option::Type)jarg2; 
  arg2 = &temp2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Rate)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  arg9 = (Handle< YieldTermStructure > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Option::Type temp2 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  temp2 = (Option::Type)jarg2; 
  arg2 = &temp2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Rate)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Date *arg7 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Option::Type temp2 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  temp2 = (Option::Type)jarg2; 
  arg2 = &temp2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Rate)jarg6; 
  arg7 = (Date *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Option::Type temp2 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  temp2 = (Option::Type)jarg2; 
  arg2 = &temp2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Date *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg6 = (Rate)jarg6; 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< IborIndex > arg5 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  if (jarg5) arg5 = *(ext::shared_ptr< IborIndex > *)jarg5; 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  ext::shared_ptr< SwapIndex > arg6 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  if (jarg6) arg6 = *(ext::shared_ptr< SwapIndex > *)jarg6; 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  ext::shared_ptr< SwapIndex > arg6 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  if (jarg6) arg6 = *(ext::shared_ptr< SwapIndex > *)jarg6; 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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 ;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg3 = (Period *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)((Gaussian1dModel const *)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_delete_Gaussian1dModel(void * jarg1) {
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  ext::shared_ptr< Gaussian1dModel > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Gaussian1dModel > *)jarg1;
  arg1 = (Gaussian1dModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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 ;
  Gsr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Gsr *)new Gsr((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 = result ? new ext::shared_ptr<  Gsr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  Gsr *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Handle< Quote > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Handle< Quote > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Handle< Quote > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Gsr *)new Gsr((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 = result ? new ext::shared_ptr<  Gsr >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Gsr_calibrateVolatilitiesIterative__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  Gsr *arg1 = (Gsr *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrateVolatilitiesIterative((std::vector< ext::shared_ptr< BlackCalibrationHelper > > 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_Gsr_calibrateVolatilitiesIterative__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  Gsr *arg1 = (Gsr *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrateVolatilitiesIterative((std::vector< ext::shared_ptr< BlackCalibrationHelper > > 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) {
  Gsr *arg1 = (Gsr *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrateVolatilitiesIterative((std::vector< ext::shared_ptr< BlackCalibrationHelper > > 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_reversion(void * jarg1) {
  void * jresult ;
  Gsr *arg1 = (Gsr *) 0 ;
  ext::shared_ptr< Gsr const > *smartarg1 = 0 ;
  Array *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Array *) &((Gsr const *)arg1)->reversion();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  Gsr *arg1 = (Gsr *) 0 ;
  ext::shared_ptr< Gsr const > *smartarg1 = 0 ;
  Array *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Array *) &((Gsr 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Gsr_parameters(void * jarg1) {
  void * jresult ;
  Gsr *arg1 = (Gsr *) 0 ;
  ext::shared_ptr< Gsr const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((Gsr 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 = new Array(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_Gsr_calibrate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  Gsr *arg1 = (Gsr *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  std::vector< bool > *arg7 = 0 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return ;
  } 
  arg7 = (std::vector< bool > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrate((std::vector< ext::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_Gsr_calibrate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  Gsr *arg1 = (Gsr *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrate((std::vector< ext::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_Gsr_calibrate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  Gsr *arg1 = (Gsr *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrate((std::vector< ext::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) {
  Gsr *arg1 = (Gsr *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrate((std::vector< ext::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_setParams(void * jarg1, void * jarg2) {
  Gsr *arg1 = (Gsr *) 0 ;
  Array *arg2 = 0 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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_Gsr_value(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  Gsr *arg1 = (Gsr *) 0 ;
  Array *arg2 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg3 = 0 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(arg1)->value((Array const &)*arg2,(std::vector< ext::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_Gsr_constraint(void * jarg1) {
  void * jresult ;
  Gsr *arg1 = (Gsr *) 0 ;
  ext::shared_ptr< Gsr const > *smartarg1 = 0 ;
  ext::shared_ptr< Constraint > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (ext::shared_ptr< Constraint > *) &((Gsr 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 = *result ? new ext::shared_ptr< Constraint >(*result) : 0; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Gsr_endCriteria(void * jarg1) {
  int jresult ;
  Gsr *arg1 = (Gsr *) 0 ;
  ext::shared_ptr< Gsr const > *smartarg1 = 0 ;
  EndCriteria::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (EndCriteria::Type)((Gsr const *)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_Gsr_problemValues(void * jarg1) {
  void * jresult ;
  Gsr *arg1 = (Gsr *) 0 ;
  ext::shared_ptr< Gsr const > *smartarg1 = 0 ;
  Array *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Array *) &((Gsr const *)arg1)->problemValues();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_Gsr_functionEvaluation(void * jarg1) {
  int jresult ;
  Gsr *arg1 = (Gsr *) 0 ;
  ext::shared_ptr< Gsr const > *smartarg1 = 0 ;
  Integer result;
  
  
  smartarg1 = (ext::shared_ptr< const Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Integer)((Gsr const *)arg1)->functionEvaluation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_Gsr(void * jarg1) {
  Gsr *arg1 = (Gsr *) 0 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Gsr > *)jarg1;
  arg1 = (Gsr *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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, void * 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 ;
  ext::shared_ptr< SwapIndex > *arg8 = 0 ;
  MarkovFunctional::ModelSettings *arg9 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull8 ;
  MarkovFunctional *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< SwaptionVolatilityStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Period > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< SwapIndex > *)jarg8 : &tempnull8; 
  arg9 = (MarkovFunctional::ModelSettings *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MarkovFunctional::ModelSettings const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MarkovFunctional *)new MarkovFunctional((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date > const &)*arg3,(std::vector< Real > const &)*arg4,(Handle< SwaptionVolatilityStructure > const &)*arg5,(std::vector< Date > const &)*arg6,(std::vector< Period > const &)*arg7,(ext::shared_ptr< SwapIndex > const &)*arg8,(MarkovFunctional::ModelSettings 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 ? new ext::shared_ptr<  MarkovFunctional >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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) {
  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 ;
  ext::shared_ptr< SwapIndex > *arg8 = 0 ;
  ext::shared_ptr< SwapIndex > tempnull8 ;
  MarkovFunctional *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< SwaptionVolatilityStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (std::vector< Period > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? (ext::shared_ptr< SwapIndex > *)jarg8 : &tempnull8; 
  {
    try {
      result = (MarkovFunctional *)new MarkovFunctional((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date > const &)*arg3,(std::vector< Real > const &)*arg4,(Handle< SwaptionVolatilityStructure > const &)*arg5,(std::vector< Date > const &)*arg6,(std::vector< Period > const &)*arg7,(ext::shared_ptr< SwapIndex > 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 ? new ext::shared_ptr<  MarkovFunctional >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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) {
  void * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Handle< OptionletVolatilityStructure > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  MarkovFunctional::ModelSettings *arg8 = 0 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  MarkovFunctional *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< OptionletVolatilityStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< OptionletVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  arg8 = (MarkovFunctional::ModelSettings *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MarkovFunctional::ModelSettings const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MarkovFunctional *)new MarkovFunctional((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date > const &)*arg3,(std::vector< Real > const &)*arg4,(Handle< OptionletVolatilityStructure > const &)*arg5,(std::vector< Date > const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(MarkovFunctional::ModelSettings 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 ? new ext::shared_ptr<  MarkovFunctional >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jresult ;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  std::vector< Date > *arg3 = 0 ;
  std::vector< Real > *arg4 = 0 ;
  Handle< OptionletVolatilityStructure > *arg5 = 0 ;
  std::vector< Date > *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  ext::shared_ptr< IborIndex > tempnull7 ;
  MarkovFunctional *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< Date > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg4 = (std::vector< Real > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg5 = (Handle< OptionletVolatilityStructure > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< OptionletVolatilityStructure > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (ext::shared_ptr< IborIndex > *)jarg7 : &tempnull7; 
  {
    try {
      result = (MarkovFunctional *)new MarkovFunctional((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date > const &)*arg3,(std::vector< Real > const &)*arg4,(Handle< OptionletVolatilityStructure > const &)*arg5,(std::vector< Date > const &)*arg6,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  MarkovFunctional >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_volatility(void * jarg1) {
  void * jresult ;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  ext::shared_ptr< MarkovFunctional > *smartarg1 = 0 ;
  Array *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MarkovFunctional > *)jarg1;
  arg1 = (MarkovFunctional *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Array *) &(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 = (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) {
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  std::vector< bool > *arg7 = 0 ;
  ext::shared_ptr< MarkovFunctional > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MarkovFunctional > *)jarg1;
  arg1 = (MarkovFunctional *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return ;
  } 
  arg7 = (std::vector< bool > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrate((std::vector< ext::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_MarkovFunctional_calibrate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  ext::shared_ptr< MarkovFunctional > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MarkovFunctional > *)jarg1;
  arg1 = (MarkovFunctional *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrate((std::vector< ext::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_MarkovFunctional_calibrate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  ext::shared_ptr< MarkovFunctional > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MarkovFunctional > *)jarg1;
  arg1 = (MarkovFunctional *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrate((std::vector< ext::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) {
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  ext::shared_ptr< MarkovFunctional > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MarkovFunctional > *)jarg1;
  arg1 = (MarkovFunctional *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrate((std::vector< ext::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_parameters(void * jarg1) {
  void * jresult ;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  ext::shared_ptr< MarkovFunctional const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const MarkovFunctional > *)jarg1;
  arg1 = (MarkovFunctional *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((MarkovFunctional 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 = new Array(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_setParams(void * jarg1, void * jarg2) {
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  Array *arg2 = 0 ;
  ext::shared_ptr< MarkovFunctional > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MarkovFunctional > *)jarg1;
  arg1 = (MarkovFunctional *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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_MarkovFunctional_value(void * jarg1, void * jarg2, void * jarg3) {
  double jresult ;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  Array *arg2 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg3 = 0 ;
  ext::shared_ptr< MarkovFunctional > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  MarkovFunctional > *)jarg1;
  arg1 = (MarkovFunctional *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(arg1)->value((Array const &)*arg2,(std::vector< ext::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_MarkovFunctional_constraint(void * jarg1) {
  void * jresult ;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  ext::shared_ptr< MarkovFunctional const > *smartarg1 = 0 ;
  ext::shared_ptr< Constraint > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const MarkovFunctional > *)jarg1;
  arg1 = (MarkovFunctional *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (ext::shared_ptr< Constraint > *) &((MarkovFunctional 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 = *result ? new ext::shared_ptr< Constraint >(*result) : 0; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_endCriteria(void * jarg1) {
  int jresult ;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  ext::shared_ptr< MarkovFunctional const > *smartarg1 = 0 ;
  EndCriteria::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const MarkovFunctional > *)jarg1;
  arg1 = (MarkovFunctional *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (EndCriteria::Type)((MarkovFunctional const *)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_MarkovFunctional_problemValues(void * jarg1) {
  void * jresult ;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  ext::shared_ptr< MarkovFunctional const > *smartarg1 = 0 ;
  Array *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const MarkovFunctional > *)jarg1;
  arg1 = (MarkovFunctional *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Array *) &((MarkovFunctional const *)arg1)->problemValues();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_MarkovFunctional_functionEvaluation(void * jarg1) {
  int jresult ;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  ext::shared_ptr< MarkovFunctional const > *smartarg1 = 0 ;
  Integer result;
  
  
  smartarg1 = (ext::shared_ptr< const MarkovFunctional > *)jarg1;
  arg1 = (MarkovFunctional *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Integer)((MarkovFunctional const *)arg1)->functionEvaluation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_MarkovFunctional(void * jarg1) {
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  ext::shared_ptr< MarkovFunctional > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MarkovFunctional > *)jarg1;
  arg1 = (MarkovFunctional *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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__SWIG_0() {
  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_new_MarkovFunctionalSettings__SWIG_1(unsigned long jarg1, double jarg2, unsigned long jarg3, double jarg4, double jarg5, double jarg6, double jarg7, int jarg8, void * jarg9) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Size arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  int arg8 ;
  std::vector< Real > *arg9 = 0 ;
  MarkovFunctional::ModelSettings *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (int)jarg8; 
  arg9 = (std::vector< Real > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MarkovFunctional::ModelSettings *)new MarkovFunctional::ModelSettings(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(std::vector< Real > 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_MarkovFunctionalSettings__SWIG_2(unsigned long jarg1, double jarg2, unsigned long jarg3, double jarg4, double jarg5, double jarg6, double jarg7, int jarg8) {
  void * jresult ;
  Size arg1 ;
  Real arg2 ;
  Size arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  int arg8 ;
  MarkovFunctional::ModelSettings *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Real)jarg6; 
  arg7 = (Real)jarg7; 
  arg8 = (int)jarg8; 
  {
    try {
      result = (MarkovFunctional::ModelSettings *)new MarkovFunctional::ModelSettings(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_MarkovFunctionalSettings_validate(void * jarg1) {
  MarkovFunctional::ModelSettings *arg1 = (MarkovFunctional::ModelSettings *) 0 ;
  
  arg1 = (MarkovFunctional::ModelSettings *)jarg1; 
  {
    try {
      (arg1)->validate();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_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 void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dCapFloorEngine__SWIG_0(void * jarg1, int jarg2, double jarg3, unsigned int jarg4, unsigned int jarg5, void * jarg6) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dCapFloorEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Gaussian1dCapFloorEngine *)new Gaussian1dCapFloorEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dCapFloorEngine__SWIG_1(void * jarg1, int jarg2, double jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dCapFloorEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Gaussian1dCapFloorEngine *)new Gaussian1dCapFloorEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dCapFloorEngine__SWIG_2(void * jarg1, int jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dCapFloorEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Gaussian1dCapFloorEngine *)new Gaussian1dCapFloorEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dCapFloorEngine__SWIG_3(void * jarg1, int jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dCapFloorEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Gaussian1dCapFloorEngine *)new Gaussian1dCapFloorEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dCapFloorEngine__SWIG_4(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dCapFloorEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (Gaussian1dCapFloorEngine *)new Gaussian1dCapFloorEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dCapFloorEngine__SWIG_5(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dCapFloorEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Gaussian1dCapFloorEngine *)new Gaussian1dCapFloorEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dCapFloorEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Gaussian1dCapFloorEngine(void * jarg1) {
  Gaussian1dCapFloorEngine *arg1 = (Gaussian1dCapFloorEngine *) 0 ;
  ext::shared_ptr< Gaussian1dCapFloorEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Gaussian1dCapFloorEngine > *)jarg1;
  arg1 = (Gaussian1dCapFloorEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, int jarg7) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Gaussian1dSwaptionEngine::Probabilities arg7 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  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 & is null", 0);
    return 0;
  } 
  arg7 = (Gaussian1dSwaptionEngine::Probabilities)jarg7; 
  {
    try {
      result = (Gaussian1dSwaptionEngine *)new Gaussian1dSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,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 = result ? new ext::shared_ptr<  Gaussian1dSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dSwaptionEngine__SWIG_1(void * jarg1, int jarg2, double jarg3, unsigned int jarg4, unsigned int jarg5, void * jarg6) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Gaussian1dSwaptionEngine *)new Gaussian1dSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dSwaptionEngine__SWIG_2(void * jarg1, int jarg2, double jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Gaussian1dSwaptionEngine *)new Gaussian1dSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dSwaptionEngine__SWIG_3(void * jarg1, int jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Gaussian1dSwaptionEngine *)new Gaussian1dSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dSwaptionEngine__SWIG_4(void * jarg1, int jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Gaussian1dSwaptionEngine *)new Gaussian1dSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dSwaptionEngine__SWIG_5(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (Gaussian1dSwaptionEngine *)new Gaussian1dSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dSwaptionEngine__SWIG_6(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Gaussian1dSwaptionEngine *)new Gaussian1dSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Gaussian1dSwaptionEngine(void * jarg1) {
  Gaussian1dSwaptionEngine *arg1 = (Gaussian1dSwaptionEngine *) 0 ;
  ext::shared_ptr< Gaussian1dSwaptionEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Gaussian1dSwaptionEngine > *)jarg1;
  arg1 = (Gaussian1dSwaptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dJamshidianSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Gaussian1dJamshidianSwaptionEngine *)new Gaussian1dJamshidianSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dJamshidianSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Gaussian1dJamshidianSwaptionEngine(void * jarg1) {
  Gaussian1dJamshidianSwaptionEngine *arg1 = (Gaussian1dJamshidianSwaptionEngine *) 0 ;
  ext::shared_ptr< Gaussian1dJamshidianSwaptionEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Gaussian1dJamshidianSwaptionEngine > *)jarg1;
  arg1 = (Gaussian1dJamshidianSwaptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, int jarg8) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  Gaussian1dNonstandardSwaptionEngine::Probabilities arg8 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dNonstandardSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  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 & is null", 0);
    return 0;
  } 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg8 = (Gaussian1dNonstandardSwaptionEngine::Probabilities)jarg8; 
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEngine *)new Gaussian1dNonstandardSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 * jarg7) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dNonstandardSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  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 & is null", 0);
    return 0;
  } 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEngine *)new Gaussian1dNonstandardSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dNonstandardSwaptionEngine__SWIG_2(void * jarg1, int jarg2, double jarg3, unsigned int jarg4, unsigned int jarg5, void * jarg6) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dNonstandardSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEngine *)new Gaussian1dNonstandardSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dNonstandardSwaptionEngine__SWIG_3(void * jarg1, int jarg2, double jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dNonstandardSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEngine *)new Gaussian1dNonstandardSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dNonstandardSwaptionEngine__SWIG_4(void * jarg1, int jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dNonstandardSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEngine *)new Gaussian1dNonstandardSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dNonstandardSwaptionEngine__SWIG_5(void * jarg1, int jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dNonstandardSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEngine *)new Gaussian1dNonstandardSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dNonstandardSwaptionEngine__SWIG_6(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dNonstandardSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEngine *)new Gaussian1dNonstandardSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dNonstandardSwaptionEngine__SWIG_7(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dNonstandardSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEngine *)new Gaussian1dNonstandardSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Gaussian1dNonstandardSwaptionEngine(void * jarg1) {
  Gaussian1dNonstandardSwaptionEngine *arg1 = (Gaussian1dNonstandardSwaptionEngine *) 0 ;
  ext::shared_ptr< Gaussian1dNonstandardSwaptionEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine > *)jarg1;
  arg1 = (Gaussian1dNonstandardSwaptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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 ;
  ext::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 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  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 & is null", 0);
    return 0;
  } 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  arg9 = (Gaussian1dFloatFloatSwaptionEngine::Probabilities)jarg9; 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  bool arg8 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  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 & is null", 0);
    return 0;
  } 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg8 = jarg8 ? true : false; 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  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 & is null", 0);
    return 0;
  } 
  arg7 = (Handle< YieldTermStructure > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_5(void * jarg1, int jarg2, double jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_6(void * jarg1, int jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_7(void * jarg1, int jarg2) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_8(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempnull1 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Gaussian1dModel > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::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 = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Gaussian1dFloatFloatSwaptionEngine(void * jarg1) {
  Gaussian1dFloatFloatSwaptionEngine *arg1 = (Gaussian1dFloatFloatSwaptionEngine *) 0 ;
  ext::shared_ptr< Gaussian1dFloatFloatSwaptionEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine > *)jarg1;
  arg1 = (Gaussian1dFloatFloatSwaptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 unsigned long SWIGSTDCALL CSharp_QuantLib_SegmentIntegral_numberOfEvaluations(void * jarg1) {
  unsigned long jresult ;
  SegmentIntegral *arg1 = (SegmentIntegral *) 0 ;
  Size result;
  
  arg1 = (SegmentIntegral *)jarg1; 
  {
    try {
      result = ((SegmentIntegral const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_SegmentIntegral_calculate(void * jarg1, void * jarg2, double jarg3, double jarg4) {
  double jresult ;
  SegmentIntegral *arg1 = (SegmentIntegral *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (SegmentIntegral *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)SegmentIntegral_calculate(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_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 unsigned long SWIGSTDCALL CSharp_QuantLib_TrapezoidIntegralDefault_numberOfEvaluations(void * jarg1) {
  unsigned long jresult ;
  TrapezoidIntegral< Default > *arg1 = (TrapezoidIntegral< Default > *) 0 ;
  Size result;
  
  arg1 = (TrapezoidIntegral< Default > *)jarg1; 
  {
    try {
      result = ((TrapezoidIntegral< Default > const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_TrapezoidIntegralDefault_calculate(void * jarg1, void * jarg2, double jarg3, double jarg4) {
  double jresult ;
  TrapezoidIntegral< Default > *arg1 = (TrapezoidIntegral< Default > *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (TrapezoidIntegral< Default > *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)TrapezoidIntegral_Sl_Default_Sg__calculate(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_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 unsigned long SWIGSTDCALL CSharp_QuantLib_TrapezoidIntegralMidPoint_numberOfEvaluations(void * jarg1) {
  unsigned long jresult ;
  TrapezoidIntegral< MidPoint > *arg1 = (TrapezoidIntegral< MidPoint > *) 0 ;
  Size result;
  
  arg1 = (TrapezoidIntegral< MidPoint > *)jarg1; 
  {
    try {
      result = ((TrapezoidIntegral< MidPoint > const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_TrapezoidIntegralMidPoint_calculate(void * jarg1, void * jarg2, double jarg3, double jarg4) {
  double jresult ;
  TrapezoidIntegral< MidPoint > *arg1 = (TrapezoidIntegral< MidPoint > *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (TrapezoidIntegral< MidPoint > *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)TrapezoidIntegral_Sl_MidPoint_Sg__calculate(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_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 unsigned long SWIGSTDCALL CSharp_QuantLib_SimpsonIntegral_numberOfEvaluations(void * jarg1) {
  unsigned long jresult ;
  SimpsonIntegral *arg1 = (SimpsonIntegral *) 0 ;
  Size result;
  
  arg1 = (SimpsonIntegral *)jarg1; 
  {
    try {
      result = ((SimpsonIntegral const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_SimpsonIntegral_calculate(void * jarg1, void * jarg2, double jarg3, double jarg4) {
  double jresult ;
  SimpsonIntegral *arg1 = (SimpsonIntegral *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (SimpsonIntegral *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)SimpsonIntegral_calculate(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_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 unsigned long SWIGSTDCALL CSharp_QuantLib_GaussKronrodAdaptive_numberOfEvaluations(void * jarg1) {
  unsigned long jresult ;
  GaussKronrodAdaptive *arg1 = (GaussKronrodAdaptive *) 0 ;
  Size result;
  
  arg1 = (GaussKronrodAdaptive *)jarg1; 
  {
    try {
      result = ((GaussKronrodAdaptive const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_GaussKronrodAdaptive_calculate(void * jarg1, void * jarg2, double jarg3, double jarg4) {
  double jresult ;
  GaussKronrodAdaptive *arg1 = (GaussKronrodAdaptive *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (GaussKronrodAdaptive *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)GaussKronrodAdaptive_calculate(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_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 unsigned long SWIGSTDCALL CSharp_QuantLib_GaussKronrodNonAdaptive_numberOfEvaluations(void * jarg1) {
  unsigned long jresult ;
  GaussKronrodNonAdaptive *arg1 = (GaussKronrodNonAdaptive *) 0 ;
  Size result;
  
  arg1 = (GaussKronrodNonAdaptive *)jarg1; 
  {
    try {
      result = ((GaussKronrodNonAdaptive const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_GaussKronrodNonAdaptive_calculate(void * jarg1, void * jarg2, double jarg3, double jarg4) {
  double jresult ;
  GaussKronrodNonAdaptive *arg1 = (GaussKronrodNonAdaptive *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (GaussKronrodNonAdaptive *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)GaussKronrodNonAdaptive_calculate(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_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 unsigned long SWIGSTDCALL CSharp_QuantLib_GaussLobattoIntegral_numberOfEvaluations(void * jarg1) {
  unsigned long jresult ;
  GaussLobattoIntegral *arg1 = (GaussLobattoIntegral *) 0 ;
  Size result;
  
  arg1 = (GaussLobattoIntegral *)jarg1; 
  {
    try {
      result = ((GaussLobattoIntegral const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_GaussLobattoIntegral_calculate(void * jarg1, void * jarg2, double jarg3, double jarg4) {
  double jresult ;
  GaussLobattoIntegral *arg1 = (GaussLobattoIntegral *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (GaussLobattoIntegral *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)GaussLobattoIntegral_calculate(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_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 unsigned long SWIGSTDCALL CSharp_QuantLib_GaussianQuadrature_order(void * jarg1) {
  unsigned long jresult ;
  GaussianQuadrature *arg1 = (GaussianQuadrature *) 0 ;
  Size result;
  
  arg1 = (GaussianQuadrature *)jarg1; 
  {
    try {
      result = ((GaussianQuadrature const *)arg1)->order();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_GaussianQuadrature_weights(void * jarg1) {
  void * jresult ;
  GaussianQuadrature *arg1 = (GaussianQuadrature *) 0 ;
  Array result;
  
  arg1 = (GaussianQuadrature *)jarg1; 
  {
    try {
      result = GaussianQuadrature_weights(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GaussianQuadrature_x(void * jarg1) {
  void * jresult ;
  GaussianQuadrature *arg1 = (GaussianQuadrature *) 0 ;
  Array result;
  
  arg1 = (GaussianQuadrature *)jarg1; 
  {
    try {
      result = GaussianQuadrature_x(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_GaussianQuadrature_calculate(void * jarg1, void * jarg2) {
  double jresult ;
  GaussianQuadrature *arg1 = (GaussianQuadrature *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real result;
  
  arg1 = (GaussianQuadrature *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  {
    try {
      result = (Real)GaussianQuadrature_calculate(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_GaussianQuadrature(void * jarg1) {
  GaussianQuadrature *arg1 = (GaussianQuadrature *) 0 ;
  
  arg1 = (GaussianQuadrature *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 void * SWIGSTDCALL CSharp_QuantLib_new_TanhSinhIntegral__SWIG_0(double jarg1, unsigned long jarg2, double jarg3) {
  void * jresult ;
  Real arg1 ;
  Size arg2 ;
  Real arg3 ;
  TanhSinhIntegral *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (TanhSinhIntegral *)new TanhSinhIntegral(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_TanhSinhIntegral__SWIG_1(double jarg1, unsigned long jarg2) {
  void * jresult ;
  Real arg1 ;
  Size arg2 ;
  TanhSinhIntegral *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (TanhSinhIntegral *)new TanhSinhIntegral(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_TanhSinhIntegral__SWIG_2(double jarg1) {
  void * jresult ;
  Real arg1 ;
  TanhSinhIntegral *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (TanhSinhIntegral *)new TanhSinhIntegral(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_TanhSinhIntegral__SWIG_3() {
  void * jresult ;
  TanhSinhIntegral *result = 0 ;
  
  {
    try {
      result = (TanhSinhIntegral *)new TanhSinhIntegral();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_TanhSinhIntegral_numberOfEvaluations(void * jarg1) {
  unsigned long jresult ;
  TanhSinhIntegral *arg1 = (TanhSinhIntegral *) 0 ;
  Size result;
  
  arg1 = (TanhSinhIntegral *)jarg1; 
  {
    try {
      result = ((TanhSinhIntegral const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_TanhSinhIntegral_calculate(void * jarg1, void * jarg2, double jarg3, double jarg4) {
  double jresult ;
  TanhSinhIntegral *arg1 = (TanhSinhIntegral *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (TanhSinhIntegral *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)TanhSinhIntegral_calculate(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_TanhSinhIntegral(void * jarg1) {
  TanhSinhIntegral *arg1 = (TanhSinhIntegral *) 0 ;
  
  arg1 = (TanhSinhIntegral *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExpSinhIntegral__SWIG_0(double jarg1, unsigned long jarg2) {
  void * jresult ;
  Real arg1 ;
  Size arg2 ;
  ExpSinhIntegral *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (ExpSinhIntegral *)new ExpSinhIntegral(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_ExpSinhIntegral__SWIG_1(double jarg1) {
  void * jresult ;
  Real arg1 ;
  ExpSinhIntegral *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (ExpSinhIntegral *)new ExpSinhIntegral(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExpSinhIntegral__SWIG_2() {
  void * jresult ;
  ExpSinhIntegral *result = 0 ;
  
  {
    try {
      result = (ExpSinhIntegral *)new ExpSinhIntegral();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_ExpSinhIntegral_integrate(void * jarg1, void * jarg2) {
  double jresult ;
  ExpSinhIntegral *arg1 = (ExpSinhIntegral *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real result;
  
  arg1 = (ExpSinhIntegral *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  {
    try {
      result = (Real)ExpSinhIntegral_integrate(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 long SWIGSTDCALL CSharp_QuantLib_ExpSinhIntegral_numberOfEvaluations(void * jarg1) {
  unsigned long jresult ;
  ExpSinhIntegral *arg1 = (ExpSinhIntegral *) 0 ;
  Size result;
  
  arg1 = (ExpSinhIntegral *)jarg1; 
  {
    try {
      result = ((ExpSinhIntegral const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_ExpSinhIntegral_calculate(void * jarg1, void * jarg2, double jarg3, double jarg4) {
  double jresult ;
  ExpSinhIntegral *arg1 = (ExpSinhIntegral *) 0 ;
  UnaryFunctionDelegate *arg2 = (UnaryFunctionDelegate *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real result;
  
  arg1 = (ExpSinhIntegral *)jarg1; 
  arg2 = (UnaryFunctionDelegate *)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (Real)ExpSinhIntegral_calculate(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_ExpSinhIntegral(void * jarg1) {
  ExpSinhIntegral *arg1 = (ExpSinhIntegral *) 0 ;
  
  arg1 = (ExpSinhIntegral *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  LocalConstantVol *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Volatility)jarg2; 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (LocalConstantVol *)new LocalConstantVol((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 = result ? new ext::shared_ptr<  LocalConstantVol >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  LocalConstantVol *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (LocalConstantVol *)new LocalConstantVol((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 = result ? new ext::shared_ptr<  LocalConstantVol >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  LocalConstantVol *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Volatility)jarg3; 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (LocalConstantVol *)new LocalConstantVol(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 = result ? new ext::shared_ptr<  LocalConstantVol >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  LocalConstantVol *result = 0 ;
  
  arg1 = (Integer)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (LocalConstantVol *)new LocalConstantVol(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 = result ? new ext::shared_ptr<  LocalConstantVol >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LocalConstantVol(void * jarg1) {
  LocalConstantVol *arg1 = (LocalConstantVol *) 0 ;
  ext::shared_ptr< LocalConstantVol > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  LocalConstantVol > *)jarg1;
  arg1 = (LocalConstantVol *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  LocalVolSurface *result = 0 ;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (LocalVolSurface *)new LocalVolSurface((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 = result ? new ext::shared_ptr<  LocalVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  LocalVolSurface *result = 0 ;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (LocalVolSurface *)new LocalVolSurface((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 = result ? new ext::shared_ptr<  LocalVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LocalVolSurface(void * jarg1) {
  LocalVolSurface *arg1 = (LocalVolSurface *) 0 ;
  ext::shared_ptr< LocalVolSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  LocalVolSurface > *)jarg1;
  arg1 = (LocalVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoExceptLocalVolSurface__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, double jarg5) {
  void * jresult ;
  Handle< BlackVolTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Real arg5 ;
  NoExceptLocalVolSurface *result = 0 ;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Handle< Quote > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (NoExceptLocalVolSurface *)new NoExceptLocalVolSurface((Handle< BlackVolTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > 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 = result ? new ext::shared_ptr<  NoExceptLocalVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NoExceptLocalVolSurface__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5) {
  void * jresult ;
  Handle< BlackVolTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  NoExceptLocalVolSurface *result = 0 ;
  
  arg1 = (Handle< BlackVolTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< BlackVolTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< YieldTermStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (NoExceptLocalVolSurface *)new NoExceptLocalVolSurface((Handle< BlackVolTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*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 ? new ext::shared_ptr<  NoExceptLocalVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NoExceptLocalVolSurface(void * jarg1) {
  NoExceptLocalVolSurface *arg1 = (NoExceptLocalVolSurface *) 0 ;
  ext::shared_ptr< NoExceptLocalVolSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  NoExceptLocalVolSurface > *)jarg1;
  arg1 = (NoExceptLocalVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedLocalVolSurface__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, int jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  FixedLocalVolSurface::Extrapolation arg6 ;
  FixedLocalVolSurface::Extrapolation arg7 ;
  Matrix *argp4 ;
  FixedLocalVolSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  argp4 = (Matrix *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Matrix", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (FixedLocalVolSurface::Extrapolation)jarg6; 
  arg7 = (FixedLocalVolSurface::Extrapolation)jarg7; 
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_0((Date const &)*arg1,(std::vector< Date > const &)*arg2,(std::vector< double > const &)*arg3,SWIG_STD_MOVE(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 = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedLocalVolSurface__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  FixedLocalVolSurface::Extrapolation arg6 ;
  Matrix *argp4 ;
  FixedLocalVolSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  argp4 = (Matrix *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Matrix", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (FixedLocalVolSurface::Extrapolation)jarg6; 
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_0((Date const &)*arg1,(std::vector< Date > const &)*arg2,(std::vector< double > const &)*arg3,SWIG_STD_MOVE(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 = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedLocalVolSurface__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  Matrix *argp4 ;
  FixedLocalVolSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  argp4 = (Matrix *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Matrix", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_0((Date const &)*arg1,(std::vector< Date > const &)*arg2,(std::vector< double > const &)*arg3,SWIG_STD_MOVE(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 = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedLocalVolSurface__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, int jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Time > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  FixedLocalVolSurface::Extrapolation arg6 ;
  FixedLocalVolSurface::Extrapolation arg7 ;
  Matrix *argp4 ;
  FixedLocalVolSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Time > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  argp4 = (Matrix *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Matrix", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (FixedLocalVolSurface::Extrapolation)jarg6; 
  arg7 = (FixedLocalVolSurface::Extrapolation)jarg7; 
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_3((Date const &)*arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,SWIG_STD_MOVE(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 = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedLocalVolSurface__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Time > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  FixedLocalVolSurface::Extrapolation arg6 ;
  Matrix *argp4 ;
  FixedLocalVolSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Time > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  argp4 = (Matrix *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Matrix", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (FixedLocalVolSurface::Extrapolation)jarg6; 
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_3((Date const &)*arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,SWIG_STD_MOVE(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 = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedLocalVolSurface__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Time > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  Matrix *argp4 ;
  FixedLocalVolSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Time > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  argp4 = (Matrix *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Matrix", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_3((Date const &)*arg1,(std::vector< double > const &)*arg2,(std::vector< double > const &)*arg3,SWIG_STD_MOVE(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 = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedLocalVolSurface__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, int jarg7) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Time > *arg2 = 0 ;
  std::vector< std::vector< Real > > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  FixedLocalVolSurface::Extrapolation arg6 ;
  FixedLocalVolSurface::Extrapolation arg7 ;
  Matrix *argp4 ;
  FixedLocalVolSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Time > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< std::vector< Real > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Real > > const & is null", 0);
    return 0;
  } 
  argp4 = (Matrix *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Matrix", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (FixedLocalVolSurface::Extrapolation)jarg6; 
  arg7 = (FixedLocalVolSurface::Extrapolation)jarg7; 
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_6((Date const &)*arg1,(std::vector< double > const &)*arg2,(std::vector< std::vector< double > > const &)*arg3,SWIG_STD_MOVE(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 = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedLocalVolSurface__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Time > *arg2 = 0 ;
  std::vector< std::vector< Real > > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  FixedLocalVolSurface::Extrapolation arg6 ;
  Matrix *argp4 ;
  FixedLocalVolSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Time > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< std::vector< Real > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Real > > const & is null", 0);
    return 0;
  } 
  argp4 = (Matrix *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Matrix", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg6 = (FixedLocalVolSurface::Extrapolation)jarg6; 
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_6((Date const &)*arg1,(std::vector< double > const &)*arg2,(std::vector< std::vector< double > > const &)*arg3,SWIG_STD_MOVE(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 = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FixedLocalVolSurface__SWIG_8(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Time > *arg2 = 0 ;
  std::vector< std::vector< Real > > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  Matrix *argp4 ;
  FixedLocalVolSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Time > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< std::vector< Real > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Real > > const & is null", 0);
    return 0;
  } 
  argp4 = (Matrix *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Matrix", 0);
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (DayCounter *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_6((Date const &)*arg1,(std::vector< double > const &)*arg2,(std::vector< std::vector< double > > const &)*arg3,SWIG_STD_MOVE(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 = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_FixedLocalVolSurface_setInterpolation__SWIG_0(void * jarg1, const char * jarg2) {
  FixedLocalVolSurface *arg1 = (FixedLocalVolSurface *) 0 ;
  std::string *arg2 = 0 ;
  ext::shared_ptr< FixedLocalVolSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FixedLocalVolSurface > *)jarg1;
  arg1 = (FixedLocalVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      FixedLocalVolSurface_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_FixedLocalVolSurface_setInterpolation__SWIG_1(void * jarg1) {
  FixedLocalVolSurface *arg1 = (FixedLocalVolSurface *) 0 ;
  ext::shared_ptr< FixedLocalVolSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FixedLocalVolSurface > *)jarg1;
  arg1 = (FixedLocalVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      FixedLocalVolSurface_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 void SWIGSTDCALL CSharp_QuantLib_delete_FixedLocalVolSurface(void * jarg1) {
  FixedLocalVolSurface *arg1 = (FixedLocalVolSurface *) 0 ;
  ext::shared_ptr< FixedLocalVolSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FixedLocalVolSurface > *)jarg1;
  arg1 = (FixedLocalVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GridModelLocalVolSurface__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< std::vector< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  GridModelLocalVolSurface::Extrapolation arg5 ;
  GridModelLocalVolSurface::Extrapolation arg6 ;
  GridModelLocalVolSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< std::vector< Real > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Real > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (GridModelLocalVolSurface::Extrapolation)jarg5; 
  arg6 = (GridModelLocalVolSurface::Extrapolation)jarg6; 
  {
    try {
      result = (GridModelLocalVolSurface *)new_GridModelLocalVolSurface__SWIG_0((Date const &)*arg1,(std::vector< Date > const &)*arg2,(std::vector< std::vector< double > > 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 ? new ext::shared_ptr<  GridModelLocalVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GridModelLocalVolSurface__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< std::vector< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  GridModelLocalVolSurface::Extrapolation arg5 ;
  GridModelLocalVolSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< std::vector< Real > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Real > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg5 = (GridModelLocalVolSurface::Extrapolation)jarg5; 
  {
    try {
      result = (GridModelLocalVolSurface *)new_GridModelLocalVolSurface__SWIG_0((Date const &)*arg1,(std::vector< Date > const &)*arg2,(std::vector< 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 = result ? new ext::shared_ptr<  GridModelLocalVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_GridModelLocalVolSurface__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  Date *arg1 = 0 ;
  std::vector< Date > *arg2 = 0 ;
  std::vector< std::vector< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  GridModelLocalVolSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Date > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< std::vector< Real > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< Real > > const & is null", 0);
    return 0;
  } 
  arg4 = (DayCounter *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (GridModelLocalVolSurface *)new_GridModelLocalVolSurface__SWIG_0((Date const &)*arg1,(std::vector< Date > const &)*arg2,(std::vector< 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 = result ? new ext::shared_ptr<  GridModelLocalVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GridModelLocalVolSurface_parameters(void * jarg1) {
  void * jresult ;
  GridModelLocalVolSurface *arg1 = (GridModelLocalVolSurface *) 0 ;
  ext::shared_ptr< GridModelLocalVolSurface const > *smartarg1 = 0 ;
  Array result;
  
  
  smartarg1 = (ext::shared_ptr< const GridModelLocalVolSurface > *)jarg1;
  arg1 = (GridModelLocalVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((GridModelLocalVolSurface 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 = new Array(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_GridModelLocalVolSurface_calibrate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  GridModelLocalVolSurface *arg1 = (GridModelLocalVolSurface *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  std::vector< bool > *arg7 = 0 ;
  ext::shared_ptr< GridModelLocalVolSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GridModelLocalVolSurface > *)jarg1;
  arg1 = (GridModelLocalVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return ;
  } 
  arg7 = (std::vector< bool > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< bool > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrate((std::vector< ext::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_GridModelLocalVolSurface_calibrate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  GridModelLocalVolSurface *arg1 = (GridModelLocalVolSurface *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real > *arg6 = 0 ;
  ext::shared_ptr< GridModelLocalVolSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GridModelLocalVolSurface > *)jarg1;
  arg1 = (GridModelLocalVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  arg6 = (std::vector< Real > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrate((std::vector< ext::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_GridModelLocalVolSurface_calibrate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  GridModelLocalVolSurface *arg1 = (GridModelLocalVolSurface *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  ext::shared_ptr< GridModelLocalVolSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GridModelLocalVolSurface > *)jarg1;
  arg1 = (GridModelLocalVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  
  arg5 = (Constraint *)(((ext::shared_ptr< const Constraint > *)jarg5) ? ((ext::shared_ptr< const Constraint > *)jarg5)->get() : 0);
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Constraint const & reference is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrate((std::vector< ext::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_GridModelLocalVolSurface_calibrate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  GridModelLocalVolSurface *arg1 = (GridModelLocalVolSurface *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  ext::shared_ptr< GridModelLocalVolSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GridModelLocalVolSurface > *)jarg1;
  arg1 = (GridModelLocalVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< ext::shared_ptr< CalibrationHelper > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< ext::shared_ptr< CalibrationHelper > > const & is null", 0);
    return ;
  } 
  
  arg3 = (OptimizationMethod *)(((ext::shared_ptr<  OptimizationMethod > *)jarg3) ? ((ext::shared_ptr<  OptimizationMethod > *)jarg3)->get() : 0);
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "OptimizationMethod & reference is null", 0);
    return ;
  } 
  
  arg4 = (EndCriteria *)(((ext::shared_ptr< const EndCriteria > *)jarg4) ? ((ext::shared_ptr< const EndCriteria > *)jarg4)->get() : 0);
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EndCriteria const & reference is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->calibrate((std::vector< ext::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 int SWIGSTDCALL CSharp_QuantLib_GridModelLocalVolSurface_endCriteria(void * jarg1) {
  int jresult ;
  GridModelLocalVolSurface *arg1 = (GridModelLocalVolSurface *) 0 ;
  ext::shared_ptr< GridModelLocalVolSurface const > *smartarg1 = 0 ;
  EndCriteria::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const GridModelLocalVolSurface > *)jarg1;
  arg1 = (GridModelLocalVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (EndCriteria::Type)((GridModelLocalVolSurface const *)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_delete_GridModelLocalVolSurface(void * jarg1) {
  GridModelLocalVolSurface *arg1 = (GridModelLocalVolSurface *) 0 ;
  ext::shared_ptr< GridModelLocalVolSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  GridModelLocalVolSurface > *)jarg1;
  arg1 = (GridModelLocalVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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 = 0 ;
  
  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 = 0 ;
  
  arg1 = (Sample< Array > *)jarg1; 
  {
    try {
      result = (Array *) &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 = (void *)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 = 0 ;
  
  arg1 = (Sample< std::vector< Real > > *)jarg1; 
  {
    try {
      result = (std::vector< double > *) &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 = (void *)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 >(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 >(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 >(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_Xoshiro256StarStarUniformRng__SWIG_0(long jarg1) {
  void * jresult ;
  BigInteger arg1 ;
  Xoshiro256StarStarUniformRng *result = 0 ;
  
  arg1 = (BigInteger)jarg1; 
  {
    try {
      result = (Xoshiro256StarStarUniformRng *)new Xoshiro256StarStarUniformRng(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Xoshiro256StarStarUniformRng_next(void * jarg1) {
  void * jresult ;
  Xoshiro256StarStarUniformRng *arg1 = (Xoshiro256StarStarUniformRng *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (Xoshiro256StarStarUniformRng *)jarg1; 
  {
    try {
      result = ((Xoshiro256StarStarUniformRng 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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Xoshiro256StarStarUniformRng(void * jarg1) {
  Xoshiro256StarStarUniformRng *arg1 = (Xoshiro256StarStarUniformRng *) 0 ;
  
  arg1 = (Xoshiro256StarStarUniformRng *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 >(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 & 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 >(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 & 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 >(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 & 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 >(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_CentralLimitXoshiro256StarStarGaussianRng(void * jarg1) {
  void * jresult ;
  Xoshiro256StarStarUniformRng *arg1 = 0 ;
  CLGaussianRng< Xoshiro256StarStarUniformRng > *result = 0 ;
  
  arg1 = (Xoshiro256StarStarUniformRng *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xoshiro256StarStarUniformRng const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CLGaussianRng< Xoshiro256StarStarUniformRng > *)new CLGaussianRng< Xoshiro256StarStarUniformRng >((Xoshiro256StarStarUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CentralLimitXoshiro256StarStarGaussianRng_next(void * jarg1) {
  void * jresult ;
  CLGaussianRng< Xoshiro256StarStarUniformRng > *arg1 = (CLGaussianRng< Xoshiro256StarStarUniformRng > *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (CLGaussianRng< Xoshiro256StarStarUniformRng > *)jarg1; 
  {
    try {
      result = ((CLGaussianRng< Xoshiro256StarStarUniformRng > 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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CentralLimitXoshiro256StarStarGaussianRng(void * jarg1) {
  CLGaussianRng< Xoshiro256StarStarUniformRng > *arg1 = (CLGaussianRng< Xoshiro256StarStarUniformRng > *) 0 ;
  
  arg1 = (CLGaussianRng< Xoshiro256StarStarUniformRng > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & 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 >(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 & 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 >(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 & 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 >(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_BoxMullerXoshiro256StarStarGaussianRng(void * jarg1) {
  void * jresult ;
  Xoshiro256StarStarUniformRng *arg1 = 0 ;
  BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > *result = 0 ;
  
  arg1 = (Xoshiro256StarStarUniformRng *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xoshiro256StarStarUniformRng const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > *)new BoxMullerGaussianRng< Xoshiro256StarStarUniformRng >((Xoshiro256StarStarUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BoxMullerXoshiro256StarStarGaussianRng_next(void * jarg1) {
  void * jresult ;
  BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > *arg1 = (BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > *)jarg1; 
  {
    try {
      result = ((BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > 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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BoxMullerXoshiro256StarStarGaussianRng(void * jarg1) {
  BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > *arg1 = (BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > *) 0 ;
  
  arg1 = (BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & 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 >(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 & 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 >(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 & 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 >(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_MoroInvCumulativeXoshiro256StarStarGaussianRng(void * jarg1) {
  void * jresult ;
  Xoshiro256StarStarUniformRng *arg1 = 0 ;
  InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (Xoshiro256StarStarUniformRng *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xoshiro256StarStarUniformRng const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > *)new InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal >((Xoshiro256StarStarUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MoroInvCumulativeXoshiro256StarStarGaussianRng_next(void * jarg1) {
  void * jresult ;
  InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRng< Xoshiro256StarStarUniformRng,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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MoroInvCumulativeXoshiro256StarStarGaussianRng(void * jarg1) {
  InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRng< Xoshiro256StarStarUniformRng,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 & 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 >(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 & 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 >(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 & 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 >(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_InvCumulativeXoshiro256StarStarGaussianRng(void * jarg1) {
  void * jresult ;
  Xoshiro256StarStarUniformRng *arg1 = 0 ;
  InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (Xoshiro256StarStarUniformRng *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xoshiro256StarStarUniformRng const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > *)new InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal >((Xoshiro256StarStarUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InvCumulativeXoshiro256StarStarGaussianRng_next(void * jarg1) {
  void * jresult ;
  InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > *arg1 = (InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > *) 0 ;
  SwigValueWrapper< Sample< double > > result;
  
  arg1 = (InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRng< Xoshiro256StarStarUniformRng,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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_InvCumulativeXoshiro256StarStarGaussianRng(void * jarg1) {
  InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > *arg1 = (InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRng< Xoshiro256StarStarUniformRng,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 & 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 >(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 >(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_Burley2020SobolRsg__SWIG_0(unsigned long jarg1, long jarg2, int jarg3, long jarg4) {
  void * jresult ;
  Size arg1 ;
  BigInteger arg2 ;
  SobolRsg::DirectionIntegers arg3 ;
  BigInteger arg4 ;
  Burley2020SobolRsg *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (BigInteger)jarg2; 
  arg3 = (SobolRsg::DirectionIntegers)jarg3; 
  arg4 = (BigInteger)jarg4; 
  {
    try {
      result = (Burley2020SobolRsg *)new Burley2020SobolRsg(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_Burley2020SobolRsg__SWIG_1(unsigned long jarg1, long jarg2, int jarg3) {
  void * jresult ;
  Size arg1 ;
  BigInteger arg2 ;
  SobolRsg::DirectionIntegers arg3 ;
  Burley2020SobolRsg *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (BigInteger)jarg2; 
  arg3 = (SobolRsg::DirectionIntegers)jarg3; 
  {
    try {
      result = (Burley2020SobolRsg *)new Burley2020SobolRsg(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_Burley2020SobolRsg__SWIG_2(unsigned long jarg1, long jarg2) {
  void * jresult ;
  Size arg1 ;
  BigInteger arg2 ;
  Burley2020SobolRsg *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (BigInteger)jarg2; 
  {
    try {
      result = (Burley2020SobolRsg *)new Burley2020SobolRsg(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_Burley2020SobolRsg__SWIG_3(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  Burley2020SobolRsg *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (Burley2020SobolRsg *)new Burley2020SobolRsg(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Burley2020SobolRsg_nextSequence(void * jarg1) {
  void * jresult ;
  Burley2020SobolRsg *arg1 = (Burley2020SobolRsg *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (Burley2020SobolRsg *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((Burley2020SobolRsg 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_Burley2020SobolRsg_lastSequence(void * jarg1) {
  void * jresult ;
  Burley2020SobolRsg *arg1 = (Burley2020SobolRsg *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (Burley2020SobolRsg *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((Burley2020SobolRsg 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_Burley2020SobolRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  Burley2020SobolRsg *arg1 = (Burley2020SobolRsg *) 0 ;
  Size result;
  
  arg1 = (Burley2020SobolRsg *)jarg1; 
  {
    try {
      result = ((Burley2020SobolRsg 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_Burley2020SobolRsg_nextInt32Sequence(void * jarg1) {
  void * jresult ;
  Burley2020SobolRsg *arg1 = (Burley2020SobolRsg *) 0 ;
  std::vector< unsigned int > result;
  
  arg1 = (Burley2020SobolRsg *)jarg1; 
  {
    try {
      result = Burley2020SobolRsg_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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_Burley2020SobolRsg(void * jarg1) {
  Burley2020SobolRsg *arg1 = (Burley2020SobolRsg *) 0 ;
  
  arg1 = (Burley2020SobolRsg *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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_Burley2020SobolBrownianBridgeRsg(unsigned long jarg1, unsigned long jarg2) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  Burley2020SobolBrownianBridgeRsg *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Burley2020SobolBrownianBridgeRsg *)new Burley2020SobolBrownianBridgeRsg(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_Burley2020SobolBrownianBridgeRsg_nextSequence(void * jarg1) {
  void * jresult ;
  Burley2020SobolBrownianBridgeRsg *arg1 = (Burley2020SobolBrownianBridgeRsg *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (Burley2020SobolBrownianBridgeRsg *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((Burley2020SobolBrownianBridgeRsg 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_Burley2020SobolBrownianBridgeRsg_lastSequence(void * jarg1) {
  void * jresult ;
  Burley2020SobolBrownianBridgeRsg *arg1 = (Burley2020SobolBrownianBridgeRsg *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (Burley2020SobolBrownianBridgeRsg *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((Burley2020SobolBrownianBridgeRsg 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_Burley2020SobolBrownianBridgeRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  Burley2020SobolBrownianBridgeRsg *arg1 = (Burley2020SobolBrownianBridgeRsg *) 0 ;
  Size result;
  
  arg1 = (Burley2020SobolBrownianBridgeRsg *)jarg1; 
  {
    try {
      result = ((Burley2020SobolBrownianBridgeRsg 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_Burley2020SobolBrownianBridgeRsg(void * jarg1) {
  Burley2020SobolBrownianBridgeRsg *arg1 = (Burley2020SobolBrownianBridgeRsg *) 0 ;
  
  arg1 = (Burley2020SobolBrownianBridgeRsg *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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__SWIG_0(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 & 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_new_LecuyerUniformRsg__SWIG_1(unsigned long jarg1, unsigned long jarg2) {
  void * jresult ;
  Size arg1 ;
  BigNatural arg2 ;
  RandomSequenceGenerator< LecuyerUniformRng > *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (BigNatural)jarg2; 
  {
    try {
      result = (RandomSequenceGenerator< LecuyerUniformRng > *)new RandomSequenceGenerator< LecuyerUniformRng >(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_LecuyerUniformRsg__SWIG_2(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  RandomSequenceGenerator< LecuyerUniformRng > *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (RandomSequenceGenerator< LecuyerUniformRng > *)new RandomSequenceGenerator< 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_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__SWIG_0(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 & 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_new_KnuthUniformRsg__SWIG_1(unsigned long jarg1, unsigned long jarg2) {
  void * jresult ;
  Size arg1 ;
  BigNatural arg2 ;
  RandomSequenceGenerator< KnuthUniformRng > *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (BigNatural)jarg2; 
  {
    try {
      result = (RandomSequenceGenerator< KnuthUniformRng > *)new RandomSequenceGenerator< KnuthUniformRng >(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_KnuthUniformRsg__SWIG_2(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  RandomSequenceGenerator< KnuthUniformRng > *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (RandomSequenceGenerator< KnuthUniformRng > *)new RandomSequenceGenerator< 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_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__SWIG_0(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 & 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_new_MersenneTwisterUniformRsg__SWIG_1(unsigned long jarg1, unsigned long jarg2) {
  void * jresult ;
  Size arg1 ;
  BigNatural arg2 ;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (BigNatural)jarg2; 
  {
    try {
      result = (RandomSequenceGenerator< MersenneTwisterUniformRng > *)new RandomSequenceGenerator< MersenneTwisterUniformRng >(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_MersenneTwisterUniformRsg__SWIG_2(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (RandomSequenceGenerator< MersenneTwisterUniformRng > *)new RandomSequenceGenerator< 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_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_Xoshiro256StarStarUniformRsg__SWIG_0(unsigned long jarg1, void * jarg2) {
  void * jresult ;
  Size arg1 ;
  Xoshiro256StarStarUniformRng *arg2 = 0 ;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Xoshiro256StarStarUniformRng *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xoshiro256StarStarUniformRng const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *)new RandomSequenceGenerator< Xoshiro256StarStarUniformRng >(arg1,(Xoshiro256StarStarUniformRng const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Xoshiro256StarStarUniformRsg__SWIG_1(unsigned long jarg1, unsigned long jarg2) {
  void * jresult ;
  Size arg1 ;
  BigNatural arg2 ;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (BigNatural)jarg2; 
  {
    try {
      result = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *)new RandomSequenceGenerator< Xoshiro256StarStarUniformRng >(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_Xoshiro256StarStarUniformRsg__SWIG_2(unsigned long jarg1) {
  void * jresult ;
  Size arg1 ;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *result = 0 ;
  
  arg1 = (Size)jarg1; 
  {
    try {
      result = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *)new RandomSequenceGenerator< Xoshiro256StarStarUniformRng >(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_Xoshiro256StarStarUniformRsg_nextSequence(void * jarg1) {
  void * jresult ;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *arg1 = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((RandomSequenceGenerator< Xoshiro256StarStarUniformRng > 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_Xoshiro256StarStarUniformRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *arg1 = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *) 0 ;
  Size result;
  
  arg1 = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *)jarg1; 
  {
    try {
      result = ((RandomSequenceGenerator< Xoshiro256StarStarUniformRng > 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_Xoshiro256StarStarUniformRsg(void * jarg1) {
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *arg1 = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *) 0 ;
  
  arg1 = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & 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__SWIG_0(unsigned long jarg1, long jarg2, int jarg3) {
  void * jresult ;
  Size arg1 ;
  BigInteger arg2 ;
  SobolRsg::DirectionIntegers arg3 ;
  UniformLowDiscrepancySequenceGenerator *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (BigInteger)jarg2; 
  arg3 = (SobolRsg::DirectionIntegers)jarg3; 
  {
    try {
      result = (UniformLowDiscrepancySequenceGenerator *)new UniformLowDiscrepancySequenceGenerator(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_UniformLowDiscrepancySequenceGenerator__SWIG_1(unsigned long jarg1, long jarg2) {
  void * jresult ;
  Size arg1 ;
  BigInteger arg2 ;
  UniformLowDiscrepancySequenceGenerator *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (BigInteger)jarg2; 
  {
    try {
      result = (UniformLowDiscrepancySequenceGenerator *)new UniformLowDiscrepancySequenceGenerator(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_UniformLowDiscrepancySequenceGenerator__SWIG_2(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__SWIG_0(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 & 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_new_MoroInvCumulativeLecuyerGaussianRsg__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  RandomSequenceGenerator< LecuyerUniformRng > *arg1 = 0 ;
  MoroInverseCumulativeNormal *arg2 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< LecuyerUniformRng > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RandomSequenceGenerator< LecuyerUniformRng > const & is null", 0);
    return 0;
  } 
  arg2 = (MoroInverseCumulativeNormal *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MoroInverseCumulativeNormal const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal >((RandomSequenceGenerator< LecuyerUniformRng > const &)*arg1,(MoroInverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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__SWIG_0(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 & 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_new_MoroInvCumulativeKnuthGaussianRsg__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  RandomSequenceGenerator< KnuthUniformRng > *arg1 = 0 ;
  MoroInverseCumulativeNormal *arg2 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< KnuthUniformRng > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RandomSequenceGenerator< KnuthUniformRng > const & is null", 0);
    return 0;
  } 
  arg2 = (MoroInverseCumulativeNormal *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MoroInverseCumulativeNormal const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal >((RandomSequenceGenerator< KnuthUniformRng > const &)*arg1,(MoroInverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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__SWIG_0(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 & 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_new_MoroInvCumulativeMersenneTwisterGaussianRsg__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *arg1 = 0 ;
  MoroInverseCumulativeNormal *arg2 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< MersenneTwisterUniformRng > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RandomSequenceGenerator< MersenneTwisterUniformRng > const & is null", 0);
    return 0;
  } 
  arg2 = (MoroInverseCumulativeNormal *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MoroInverseCumulativeNormal const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal >((RandomSequenceGenerator< MersenneTwisterUniformRng > const &)*arg1,(MoroInverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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_MoroInvCumulativeXoshiro256StarStarGaussianRsg__SWIG_0(void * jarg1) {
  void * jresult ;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *arg1 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal >((RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MoroInvCumulativeXoshiro256StarStarGaussianRsg_nextSequence(void * jarg1) {
  void * jresult ;
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,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_MoroInvCumulativeXoshiro256StarStarGaussianRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  Size result;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,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_MoroInvCumulativeXoshiro256StarStarGaussianRsg(void * jarg1) {
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,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__SWIG_0(void * jarg1) {
  void * jresult ;
  HaltonRsg *arg1 = 0 ;
  InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (HaltonRsg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "HaltonRsg const & 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_new_MoroInvCumulativeHaltonGaussianRsg__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  HaltonRsg *arg1 = 0 ;
  MoroInverseCumulativeNormal *arg2 = 0 ;
  InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (HaltonRsg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "HaltonRsg const & is null", 0);
    return 0;
  } 
  arg2 = (MoroInverseCumulativeNormal *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MoroInverseCumulativeNormal const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal >((HaltonRsg const &)*arg1,(MoroInverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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__SWIG_0(void * jarg1) {
  void * jresult ;
  SobolRsg *arg1 = 0 ;
  InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (SobolRsg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SobolRsg const & 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_new_MoroInvCumulativeSobolGaussianRsg__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  SobolRsg *arg1 = 0 ;
  MoroInverseCumulativeNormal *arg2 = 0 ;
  InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (SobolRsg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SobolRsg const & is null", 0);
    return 0;
  } 
  arg2 = (MoroInverseCumulativeNormal *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MoroInverseCumulativeNormal const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal >((SobolRsg const &)*arg1,(MoroInverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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_MoroInvCumulativeBurley2020SobolGaussianRsg__SWIG_0(void * jarg1) {
  void * jresult ;
  Burley2020SobolRsg *arg1 = 0 ;
  InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *result = 0 ;
  
  arg1 = (Burley2020SobolRsg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Burley2020SobolRsg const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal >((Burley2020SobolRsg const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MoroInvCumulativeBurley2020SobolGaussianRsg_nextSequence(void * jarg1) {
  void * jresult ;
  InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((InverseCumulativeRsg< Burley2020SobolRsg,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_MoroInvCumulativeBurley2020SobolGaussianRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *) 0 ;
  Size result;
  
  arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRsg< Burley2020SobolRsg,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_MoroInvCumulativeBurley2020SobolGaussianRsg(void * jarg1) {
  InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,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__SWIG_0(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 & 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_new_InvCumulativeLecuyerGaussianRsg__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  RandomSequenceGenerator< LecuyerUniformRng > *arg1 = 0 ;
  InverseCumulativeNormal *arg2 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< LecuyerUniformRng > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RandomSequenceGenerator< LecuyerUniformRng > const & is null", 0);
    return 0;
  } 
  arg2 = (InverseCumulativeNormal *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InverseCumulativeNormal const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal >((RandomSequenceGenerator< LecuyerUniformRng > const &)*arg1,(InverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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__SWIG_0(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 & 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_new_InvCumulativeKnuthGaussianRsg__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  RandomSequenceGenerator< KnuthUniformRng > *arg1 = 0 ;
  InverseCumulativeNormal *arg2 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< KnuthUniformRng > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RandomSequenceGenerator< KnuthUniformRng > const & is null", 0);
    return 0;
  } 
  arg2 = (InverseCumulativeNormal *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InverseCumulativeNormal const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal >((RandomSequenceGenerator< KnuthUniformRng > const &)*arg1,(InverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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__SWIG_0(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 & 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_new_InvCumulativeMersenneTwisterGaussianRsg__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *arg1 = 0 ;
  InverseCumulativeNormal *arg2 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< MersenneTwisterUniformRng > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RandomSequenceGenerator< MersenneTwisterUniformRng > const & is null", 0);
    return 0;
  } 
  arg2 = (InverseCumulativeNormal *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InverseCumulativeNormal const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal >((RandomSequenceGenerator< MersenneTwisterUniformRng > const &)*arg1,(InverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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_InvCumulativeXoshiro256StarStarGaussianRsg__SWIG_0(void * jarg1) {
  void * jresult ;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *arg1 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal >((RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InvCumulativeXoshiro256StarStarGaussianRsg_nextSequence(void * jarg1) {
  void * jresult ;
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,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_InvCumulativeXoshiro256StarStarGaussianRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *) 0 ;
  Size result;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,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_InvCumulativeXoshiro256StarStarGaussianRsg(void * jarg1) {
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,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__SWIG_0(void * jarg1) {
  void * jresult ;
  HaltonRsg *arg1 = 0 ;
  InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (HaltonRsg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "HaltonRsg const & 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_new_InvCumulativeHaltonGaussianRsg__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  HaltonRsg *arg1 = 0 ;
  InverseCumulativeNormal *arg2 = 0 ;
  InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (HaltonRsg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "HaltonRsg const & is null", 0);
    return 0;
  } 
  arg2 = (InverseCumulativeNormal *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InverseCumulativeNormal const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *)new InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal >((HaltonRsg const &)*arg1,(InverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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__SWIG_0(void * jarg1) {
  void * jresult ;
  SobolRsg *arg1 = 0 ;
  InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (SobolRsg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SobolRsg const & 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_new_InvCumulativeSobolGaussianRsg__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  SobolRsg *arg1 = 0 ;
  InverseCumulativeNormal *arg2 = 0 ;
  InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (SobolRsg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SobolRsg const & is null", 0);
    return 0;
  } 
  arg2 = (InverseCumulativeNormal *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InverseCumulativeNormal const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *)new InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal >((SobolRsg const &)*arg1,(InverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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_InvCumulativeBurley2020SobolGaussianRsg__SWIG_0(void * jarg1) {
  void * jresult ;
  Burley2020SobolRsg *arg1 = 0 ;
  InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *result = 0 ;
  
  arg1 = (Burley2020SobolRsg *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Burley2020SobolRsg const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *)new InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal >((Burley2020SobolRsg const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InvCumulativeBurley2020SobolGaussianRsg_nextSequence(void * jarg1) {
  void * jresult ;
  InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *) 0 ;
  Sample< std::vector< Real > > *result = 0 ;
  
  arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = (Sample< std::vector< Real > > *) &((InverseCumulativeRsg< Burley2020SobolRsg,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_InvCumulativeBurley2020SobolGaussianRsg_dimension(void * jarg1) {
  unsigned long jresult ;
  InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *) 0 ;
  Size result;
  
  arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *)jarg1; 
  {
    try {
      result = ((InverseCumulativeRsg< Burley2020SobolRsg,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_InvCumulativeBurley2020SobolGaussianRsg(void * jarg1) {
  InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *) 0 ;
  
  arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,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 & 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 & 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 double SWIGSTDCALL CSharp_QuantLib_BrownianGenerator_nextStep(void * jarg1, void * jarg2) {
  double jresult ;
  BrownianGenerator *arg1 = (BrownianGenerator *) 0 ;
  std::vector< Real > *arg2 = 0 ;
  ext::shared_ptr< BrownianGenerator > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  BrownianGenerator > *)jarg1;
  arg1 = (BrownianGenerator *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< Real > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Real)(arg1)->nextStep(*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_BrownianGenerator_nextPath(void * jarg1) {
  double jresult ;
  BrownianGenerator *arg1 = (BrownianGenerator *) 0 ;
  ext::shared_ptr< BrownianGenerator > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  BrownianGenerator > *)jarg1;
  arg1 = (BrownianGenerator *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->nextPath();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_BrownianGenerator_numberOfFactors(void * jarg1) {
  unsigned long jresult ;
  BrownianGenerator *arg1 = (BrownianGenerator *) 0 ;
  ext::shared_ptr< BrownianGenerator const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const BrownianGenerator > *)jarg1;
  arg1 = (BrownianGenerator *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BrownianGenerator const *)arg1)->numberOfFactors();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_BrownianGenerator_numberOfSteps(void * jarg1) {
  unsigned long jresult ;
  BrownianGenerator *arg1 = (BrownianGenerator *) 0 ;
  ext::shared_ptr< BrownianGenerator const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const BrownianGenerator > *)jarg1;
  arg1 = (BrownianGenerator *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((BrownianGenerator const *)arg1)->numberOfSteps();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_BrownianGenerator(void * jarg1) {
  BrownianGenerator *arg1 = (BrownianGenerator *) 0 ;
  ext::shared_ptr< BrownianGenerator > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BrownianGenerator > *)jarg1;
  arg1 = (BrownianGenerator *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_BrownianGeneratorFactory_create(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  BrownianGeneratorFactory *arg1 = (BrownianGeneratorFactory *) 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< BrownianGeneratorFactory const > *smartarg1 = 0 ;
  ext::shared_ptr< BrownianGenerator > result;
  
  
  smartarg1 = (ext::shared_ptr< const BrownianGeneratorFactory > *)jarg1;
  arg1 = (BrownianGeneratorFactory *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = ((BrownianGeneratorFactory const *)arg1)->create(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 ? new ext::shared_ptr< BrownianGenerator >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BrownianGeneratorFactory(void * jarg1) {
  BrownianGeneratorFactory *arg1 = (BrownianGeneratorFactory *) 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BrownianGeneratorFactory > *)jarg1;
  arg1 = (BrownianGeneratorFactory *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MTBrownianGenerator__SWIG_0(unsigned long jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  unsigned long arg3 ;
  MTBrownianGenerator *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (unsigned long)jarg3; 
  {
    try {
      result = (MTBrownianGenerator *)new MTBrownianGenerator(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 ? new ext::shared_ptr<  MTBrownianGenerator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_MTBrownianGenerator__SWIG_1(unsigned long jarg1, unsigned long jarg2) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  MTBrownianGenerator *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (MTBrownianGenerator *)new MTBrownianGenerator(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 ? new ext::shared_ptr<  MTBrownianGenerator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MTBrownianGenerator(void * jarg1) {
  MTBrownianGenerator *arg1 = (MTBrownianGenerator *) 0 ;
  ext::shared_ptr< MTBrownianGenerator > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MTBrownianGenerator > *)jarg1;
  arg1 = (MTBrownianGenerator *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MTBrownianGeneratorFactory(void * jarg1) {
  MTBrownianGeneratorFactory *arg1 = (MTBrownianGeneratorFactory *) 0 ;
  ext::shared_ptr< MTBrownianGeneratorFactory > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MTBrownianGeneratorFactory > *)jarg1;
  arg1 = (MTBrownianGeneratorFactory *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SobolBrownianGenerator__SWIG_0(unsigned long jarg1, unsigned long jarg2, int jarg3, unsigned long jarg4, int jarg5) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  SobolBrownianGenerator::Ordering arg3 ;
  unsigned long arg4 ;
  SobolRsg::DirectionIntegers arg5 ;
  SobolBrownianGenerator *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (SobolBrownianGenerator::Ordering)jarg3; 
  arg4 = (unsigned long)jarg4; 
  arg5 = (SobolRsg::DirectionIntegers)jarg5; 
  {
    try {
      result = (SobolBrownianGenerator *)new SobolBrownianGenerator(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 ? new ext::shared_ptr<  SobolBrownianGenerator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SobolBrownianGenerator__SWIG_1(unsigned long jarg1, unsigned long jarg2, int jarg3, unsigned long jarg4) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  SobolBrownianGenerator::Ordering arg3 ;
  unsigned long arg4 ;
  SobolBrownianGenerator *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (SobolBrownianGenerator::Ordering)jarg3; 
  arg4 = (unsigned long)jarg4; 
  {
    try {
      result = (SobolBrownianGenerator *)new SobolBrownianGenerator(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 ? new ext::shared_ptr<  SobolBrownianGenerator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SobolBrownianGenerator__SWIG_2(unsigned long jarg1, unsigned long jarg2, int jarg3) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  SobolBrownianGenerator::Ordering arg3 ;
  SobolBrownianGenerator *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (SobolBrownianGenerator::Ordering)jarg3; 
  {
    try {
      result = (SobolBrownianGenerator *)new SobolBrownianGenerator(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 ? new ext::shared_ptr<  SobolBrownianGenerator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SobolBrownianGenerator(void * jarg1) {
  SobolBrownianGenerator *arg1 = (SobolBrownianGenerator *) 0 ;
  ext::shared_ptr< SobolBrownianGenerator > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SobolBrownianGenerator > *)jarg1;
  arg1 = (SobolBrownianGenerator *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SobolBrownianGeneratorFactory__SWIG_0(int jarg1, unsigned long jarg2, int jarg3) {
  void * jresult ;
  SobolBrownianGenerator::Ordering arg1 ;
  unsigned long arg2 ;
  SobolRsg::DirectionIntegers arg3 ;
  SobolBrownianGeneratorFactory *result = 0 ;
  
  arg1 = (SobolBrownianGenerator::Ordering)jarg1; 
  arg2 = (unsigned long)jarg2; 
  arg3 = (SobolRsg::DirectionIntegers)jarg3; 
  {
    try {
      result = (SobolBrownianGeneratorFactory *)new SobolBrownianGeneratorFactory(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 ? new ext::shared_ptr<  SobolBrownianGeneratorFactory >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SobolBrownianGeneratorFactory__SWIG_1(int jarg1, unsigned long jarg2) {
  void * jresult ;
  SobolBrownianGenerator::Ordering arg1 ;
  unsigned long arg2 ;
  SobolBrownianGeneratorFactory *result = 0 ;
  
  arg1 = (SobolBrownianGenerator::Ordering)jarg1; 
  arg2 = (unsigned long)jarg2; 
  {
    try {
      result = (SobolBrownianGeneratorFactory *)new SobolBrownianGeneratorFactory(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 ? new ext::shared_ptr<  SobolBrownianGeneratorFactory >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SobolBrownianGeneratorFactory__SWIG_2(int jarg1) {
  void * jresult ;
  SobolBrownianGenerator::Ordering arg1 ;
  SobolBrownianGeneratorFactory *result = 0 ;
  
  arg1 = (SobolBrownianGenerator::Ordering)jarg1; 
  {
    try {
      result = (SobolBrownianGeneratorFactory *)new SobolBrownianGeneratorFactory(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  SobolBrownianGeneratorFactory >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SobolBrownianGeneratorFactory(void * jarg1) {
  SobolBrownianGeneratorFactory *arg1 = (SobolBrownianGeneratorFactory *) 0 ;
  ext::shared_ptr< SobolBrownianGeneratorFactory > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SobolBrownianGeneratorFactory > *)jarg1;
  arg1 = (SobolBrownianGeneratorFactory *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_EvolutionDescription__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  std::vector< Time > *arg2 = 0 ;
  std::vector< std::pair< unsigned int,unsigned int > > *arg3 = 0 ;
  EvolutionDescription *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Time > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< std::pair< unsigned int,unsigned int > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,unsigned int > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EvolutionDescription *)new_EvolutionDescription__SWIG_0((std::vector< double > const &)*arg1,(std::vector< double > const &)*arg2,(std::vector< std::pair< unsigned int,unsigned int > > 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_EvolutionDescription__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  std::vector< Time > *arg2 = 0 ;
  EvolutionDescription *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Time > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EvolutionDescription *)new_EvolutionDescription__SWIG_0((std::vector< double > 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_new_EvolutionDescription__SWIG_2(void * jarg1) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  EvolutionDescription *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (EvolutionDescription *)new_EvolutionDescription__SWIG_0((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_EvolutionDescription_rateTimes(void * jarg1) {
  void * jresult ;
  EvolutionDescription *arg1 = (EvolutionDescription *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (EvolutionDescription *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &((EvolutionDescription const *)arg1)->rateTimes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_EvolutionDescription_firstAliveRate(void * jarg1) {
  void * jresult ;
  EvolutionDescription *arg1 = (EvolutionDescription *) 0 ;
  std::vector< unsigned int > result;
  
  arg1 = (EvolutionDescription *)jarg1; 
  {
    try {
      result = EvolutionDescription_firstAliveRate((EvolutionDescription const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_EvolutionDescription_relevanceRates(void * jarg1) {
  void * jresult ;
  EvolutionDescription *arg1 = (EvolutionDescription *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > > result;
  
  arg1 = (EvolutionDescription *)jarg1; 
  {
    try {
      result = EvolutionDescription_relevanceRates((EvolutionDescription const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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< unsigned int,unsigned int > >(result); 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_EvolutionDescription_numberOfRates(void * jarg1) {
  unsigned long jresult ;
  EvolutionDescription *arg1 = (EvolutionDescription *) 0 ;
  Size result;
  
  arg1 = (EvolutionDescription *)jarg1; 
  {
    try {
      result = ((EvolutionDescription const *)arg1)->numberOfRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_EvolutionDescription_numberOfSteps(void * jarg1) {
  unsigned long jresult ;
  EvolutionDescription *arg1 = (EvolutionDescription *) 0 ;
  Size result;
  
  arg1 = (EvolutionDescription *)jarg1; 
  {
    try {
      result = ((EvolutionDescription const *)arg1)->numberOfSteps();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_EvolutionDescription(void * jarg1) {
  EvolutionDescription *arg1 = (EvolutionDescription *) 0 ;
  
  arg1 = (EvolutionDescription *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_checkCompatibility(void * jarg1, void * jarg2) {
  EvolutionDescription *arg1 = 0 ;
  std::vector< unsigned int > *arg2 = 0 ;
  
  arg1 = (EvolutionDescription *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EvolutionDescription const & is null", 0);
    return ;
  } 
  arg2 = (std::vector< unsigned int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & is null", 0);
    return ;
  } 
  {
    try {
      _checkCompatibility((EvolutionDescription const &)*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 unsigned int SWIGSTDCALL CSharp_QuantLib_isInTerminalMeasure(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  EvolutionDescription *arg1 = 0 ;
  std::vector< unsigned int > *arg2 = 0 ;
  bool result;
  
  arg1 = (EvolutionDescription *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EvolutionDescription const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< unsigned int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)_isInTerminalMeasure((EvolutionDescription const &)*arg1,(std::vector< 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_isInMoneyMarketPlusMeasure__SWIG_0(void * jarg1, void * jarg2, unsigned long jarg3) {
  unsigned int jresult ;
  EvolutionDescription *arg1 = 0 ;
  std::vector< unsigned int > *arg2 = 0 ;
  Size arg3 ;
  bool result;
  
  arg1 = (EvolutionDescription *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EvolutionDescription const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< unsigned int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & is null", 0);
    return 0;
  } 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (bool)_isInMoneyMarketPlusMeasure((EvolutionDescription const &)*arg1,(std::vector< unsigned int > const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_isInMoneyMarketPlusMeasure__SWIG_1(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  EvolutionDescription *arg1 = 0 ;
  std::vector< unsigned int > *arg2 = 0 ;
  bool result;
  
  arg1 = (EvolutionDescription *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EvolutionDescription const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< unsigned int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)_isInMoneyMarketPlusMeasure((EvolutionDescription const &)*arg1,(std::vector< 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_isInMoneyMarketMeasure(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  EvolutionDescription *arg1 = 0 ;
  std::vector< unsigned int > *arg2 = 0 ;
  bool result;
  
  arg1 = (EvolutionDescription *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EvolutionDescription const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< unsigned int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)_isInMoneyMarketMeasure((EvolutionDescription const &)*arg1,(std::vector< 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_terminalMeasure(void * jarg1) {
  void * jresult ;
  EvolutionDescription *arg1 = 0 ;
  std::vector< unsigned int > result;
  
  arg1 = (EvolutionDescription *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EvolutionDescription const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _terminalMeasure((EvolutionDescription const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_moneyMarketPlusMeasure__SWIG_0(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  EvolutionDescription *arg1 = 0 ;
  Size arg2 ;
  std::vector< unsigned int > result;
  
  arg1 = (EvolutionDescription *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EvolutionDescription const & is null", 0);
    return 0;
  } 
  arg2 = (Size)jarg2; 
  {
    try {
      result = _moneyMarketPlusMeasure((EvolutionDescription const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_moneyMarketPlusMeasure__SWIG_1(void * jarg1) {
  void * jresult ;
  EvolutionDescription *arg1 = 0 ;
  std::vector< unsigned int > result;
  
  arg1 = (EvolutionDescription *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EvolutionDescription const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _moneyMarketPlusMeasure((EvolutionDescription const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_moneyMarketMeasure(void * jarg1) {
  void * jresult ;
  EvolutionDescription *arg1 = 0 ;
  std::vector< unsigned int > result;
  
  arg1 = (EvolutionDescription *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EvolutionDescription const & is null", 0);
    return 0;
  } 
  {
    try {
      result = _moneyMarketMeasure((EvolutionDescription const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MarketModel_initialRates(void * jarg1) {
  void * jresult ;
  MarketModel *arg1 = (MarketModel *) 0 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const MarketModel > *)jarg1;
  arg1 = (MarketModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Rate > *) &((MarketModel const *)arg1)->initialRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MarketModel_displacements(void * jarg1) {
  void * jresult ;
  MarketModel *arg1 = (MarketModel *) 0 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  std::vector< Spread > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const MarketModel > *)jarg1;
  arg1 = (MarketModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Spread > *) &((MarketModel const *)arg1)->displacements();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MarketModel_evolution(void * jarg1) {
  void * jresult ;
  MarketModel *arg1 = (MarketModel *) 0 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  EvolutionDescription *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const MarketModel > *)jarg1;
  arg1 = (MarketModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (EvolutionDescription *) &((MarketModel const *)arg1)->evolution();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_MarketModel_numberOfRates(void * jarg1) {
  unsigned long jresult ;
  MarketModel *arg1 = (MarketModel *) 0 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const MarketModel > *)jarg1;
  arg1 = (MarketModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((MarketModel const *)arg1)->numberOfRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_MarketModel_numberOfFactors(void * jarg1) {
  unsigned long jresult ;
  MarketModel *arg1 = (MarketModel *) 0 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const MarketModel > *)jarg1;
  arg1 = (MarketModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((MarketModel const *)arg1)->numberOfFactors();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_MarketModel_numberOfSteps(void * jarg1) {
  unsigned long jresult ;
  MarketModel *arg1 = (MarketModel *) 0 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const MarketModel > *)jarg1;
  arg1 = (MarketModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((MarketModel const *)arg1)->numberOfSteps();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_MarketModel_pseudoRoot(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  MarketModel *arg1 = (MarketModel *) 0 ;
  Size arg2 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  Matrix *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const MarketModel > *)jarg1;
  arg1 = (MarketModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Matrix *) &((MarketModel const *)arg1)->pseudoRoot(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MarketModel_covariance(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  MarketModel *arg1 = (MarketModel *) 0 ;
  Size arg2 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  Matrix *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const MarketModel > *)jarg1;
  arg1 = (MarketModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Matrix *) &((MarketModel const *)arg1)->covariance(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MarketModel_totalCovariance(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  MarketModel *arg1 = (MarketModel *) 0 ;
  Size arg2 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  Matrix *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const MarketModel > *)jarg1;
  arg1 = (MarketModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Matrix *) &((MarketModel const *)arg1)->totalCovariance(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MarketModel_timeDependentVolatility(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  MarketModel *arg1 = (MarketModel *) 0 ;
  Size arg2 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  std::vector< Volatility > result;
  
  
  smartarg1 = (ext::shared_ptr< const MarketModel > *)jarg1;
  arg1 = (MarketModel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = ((MarketModel const *)arg1)->timeDependentVolatility(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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< Volatility >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MarketModel(void * jarg1) {
  MarketModel *arg1 = (MarketModel *) 0 ;
  ext::shared_ptr< MarketModel > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MarketModel > *)jarg1;
  arg1 = (MarketModel *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MarketModelFactory_create(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  MarketModelFactory *arg1 = (MarketModelFactory *) 0 ;
  EvolutionDescription *arg2 = 0 ;
  Size arg3 ;
  ext::shared_ptr< MarketModel > result;
  
  arg1 = (MarketModelFactory *)jarg1; 
  arg2 = (EvolutionDescription *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EvolutionDescription const & is null", 0);
    return 0;
  } 
  arg3 = (Size)jarg3; 
  {
    try {
      result = ((MarketModelFactory const *)arg1)->create((EvolutionDescription 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 ? new ext::shared_ptr< MarketModel >(result) : 0; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseConstantCorrelation_times(void * jarg1) {
  void * jresult ;
  PiecewiseConstantCorrelation *arg1 = (PiecewiseConstantCorrelation *) 0 ;
  ext::shared_ptr< PiecewiseConstantCorrelation const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseConstantCorrelation > *)jarg1;
  arg1 = (PiecewiseConstantCorrelation *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseConstantCorrelation 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseConstantCorrelation_rateTimes(void * jarg1) {
  void * jresult ;
  PiecewiseConstantCorrelation *arg1 = (PiecewiseConstantCorrelation *) 0 ;
  ext::shared_ptr< PiecewiseConstantCorrelation const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseConstantCorrelation > *)jarg1;
  arg1 = (PiecewiseConstantCorrelation *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((PiecewiseConstantCorrelation const *)arg1)->rateTimes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseConstantCorrelation_correlations(void * jarg1) {
  void * jresult ;
  PiecewiseConstantCorrelation *arg1 = (PiecewiseConstantCorrelation *) 0 ;
  ext::shared_ptr< PiecewiseConstantCorrelation const > *smartarg1 = 0 ;
  std::vector< Matrix > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseConstantCorrelation > *)jarg1;
  arg1 = (PiecewiseConstantCorrelation *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Matrix > *) &((PiecewiseConstantCorrelation const *)arg1)->correlations();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_PiecewiseConstantCorrelation_correlation(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  PiecewiseConstantCorrelation *arg1 = (PiecewiseConstantCorrelation *) 0 ;
  Size arg2 ;
  ext::shared_ptr< PiecewiseConstantCorrelation const > *smartarg1 = 0 ;
  Matrix *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseConstantCorrelation > *)jarg1;
  arg1 = (PiecewiseConstantCorrelation *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Matrix *) &((PiecewiseConstantCorrelation const *)arg1)->correlation(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_PiecewiseConstantCorrelation_numberOfRates(void * jarg1) {
  unsigned long jresult ;
  PiecewiseConstantCorrelation *arg1 = (PiecewiseConstantCorrelation *) 0 ;
  ext::shared_ptr< PiecewiseConstantCorrelation const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const PiecewiseConstantCorrelation > *)jarg1;
  arg1 = (PiecewiseConstantCorrelation *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((PiecewiseConstantCorrelation const *)arg1)->numberOfRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_PiecewiseConstantCorrelation(void * jarg1) {
  PiecewiseConstantCorrelation *arg1 = (PiecewiseConstantCorrelation *) 0 ;
  ext::shared_ptr< PiecewiseConstantCorrelation > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  PiecewiseConstantCorrelation > *)jarg1;
  arg1 = (PiecewiseConstantCorrelation *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialForwardCorrelation__SWIG_0(void * jarg1, double jarg2, double jarg3, double jarg4, void * jarg5) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  std::vector< Time > arg5 ;
  std::vector< Time > *argp5 ;
  ExponentialForwardCorrelation *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  argp5 = (std::vector< Time > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Time >", 0);
    return 0;
  }
  arg5 = *argp5; 
  {
    try {
      result = (ExponentialForwardCorrelation *)new ExponentialForwardCorrelation((std::vector< Time > 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 ? new ext::shared_ptr<  ExponentialForwardCorrelation >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialForwardCorrelation__SWIG_1(void * jarg1, double jarg2, double jarg3, double jarg4) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  ExponentialForwardCorrelation *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (ExponentialForwardCorrelation *)new ExponentialForwardCorrelation((std::vector< Time > 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 ? new ext::shared_ptr<  ExponentialForwardCorrelation >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialForwardCorrelation__SWIG_2(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  ExponentialForwardCorrelation *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (ExponentialForwardCorrelation *)new ExponentialForwardCorrelation((std::vector< Time > 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 ? new ext::shared_ptr<  ExponentialForwardCorrelation >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialForwardCorrelation__SWIG_3(void * jarg1, double jarg2) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  Real arg2 ;
  ExponentialForwardCorrelation *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (ExponentialForwardCorrelation *)new ExponentialForwardCorrelation((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 = result ? new ext::shared_ptr<  ExponentialForwardCorrelation >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ExponentialForwardCorrelation__SWIG_4(void * jarg1) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  ExponentialForwardCorrelation *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (ExponentialForwardCorrelation *)new ExponentialForwardCorrelation((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 = result ? new ext::shared_ptr<  ExponentialForwardCorrelation >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ExponentialForwardCorrelation(void * jarg1) {
  ExponentialForwardCorrelation *arg1 = (ExponentialForwardCorrelation *) 0 ;
  ext::shared_ptr< ExponentialForwardCorrelation > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ExponentialForwardCorrelation > *)jarg1;
  arg1 = (ExponentialForwardCorrelation *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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_CurveState_numberOfRates(void * jarg1) {
  unsigned long jresult ;
  CurveState *arg1 = (CurveState *) 0 ;
  Size result;
  
  arg1 = (CurveState *)jarg1; 
  {
    try {
      result = ((CurveState const *)arg1)->numberOfRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_CurveState_rateTimes(void * jarg1) {
  void * jresult ;
  CurveState *arg1 = (CurveState *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (CurveState *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &((CurveState const *)arg1)->rateTimes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CurveState_rateTaus(void * jarg1) {
  void * jresult ;
  CurveState *arg1 = (CurveState *) 0 ;
  std::vector< Time > *result = 0 ;
  
  arg1 = (CurveState *)jarg1; 
  {
    try {
      result = (std::vector< Time > *) &((CurveState const *)arg1)->rateTaus();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_CurveState_discountRatio(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  double jresult ;
  CurveState *arg1 = (CurveState *) 0 ;
  Size arg2 ;
  Size arg3 ;
  Real result;
  
  arg1 = (CurveState *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (Real)((CurveState const *)arg1)->discountRatio(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_CurveState_forwardRate(void * jarg1, unsigned long jarg2) {
  double jresult ;
  CurveState *arg1 = (CurveState *) 0 ;
  Size arg2 ;
  Rate result;
  
  arg1 = (CurveState *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Rate)((CurveState const *)arg1)->forwardRate(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CurveState_coterminalSwapAnnuity(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  double jresult ;
  CurveState *arg1 = (CurveState *) 0 ;
  Size arg2 ;
  Size arg3 ;
  Rate result;
  
  arg1 = (CurveState *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (Rate)((CurveState const *)arg1)->coterminalSwapAnnuity(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_CurveState_coterminalSwapRate(void * jarg1, unsigned long jarg2) {
  double jresult ;
  CurveState *arg1 = (CurveState *) 0 ;
  Size arg2 ;
  Rate result;
  
  arg1 = (CurveState *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (Rate)((CurveState const *)arg1)->coterminalSwapRate(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CurveState_cmSwapAnnuity(void * jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4) {
  double jresult ;
  CurveState *arg1 = (CurveState *) 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Rate result;
  
  arg1 = (CurveState *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (Rate)((CurveState const *)arg1)->cmSwapAnnuity(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_CurveState_cmSwapRate(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  double jresult ;
  CurveState *arg1 = (CurveState *) 0 ;
  Size arg2 ;
  Size arg3 ;
  Rate result;
  
  arg1 = (CurveState *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (Rate)((CurveState const *)arg1)->cmSwapRate(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_CurveState_forwardRates(void * jarg1) {
  void * jresult ;
  CurveState *arg1 = (CurveState *) 0 ;
  std::vector< Rate > *result = 0 ;
  
  arg1 = (CurveState *)jarg1; 
  {
    try {
      result = (std::vector< Rate > *) &((CurveState const *)arg1)->forwardRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CurveState_cmSwapRates(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  CurveState *arg1 = (CurveState *) 0 ;
  Size arg2 ;
  std::vector< Rate > *result = 0 ;
  
  arg1 = (CurveState *)jarg1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (std::vector< Rate > *) &((CurveState const *)arg1)->cmSwapRates(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_CurveState_swapRate(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  double jresult ;
  CurveState *arg1 = (CurveState *) 0 ;
  Size arg2 ;
  Size arg3 ;
  Rate result;
  
  arg1 = (CurveState *)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (Rate)((CurveState const *)arg1)->swapRate(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_CurveState(void * jarg1) {
  CurveState *arg1 = (CurveState *) 0 ;
  
  arg1 = (CurveState *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LMMCurveState(void * jarg1) {
  void * jresult ;
  std::vector< Time > *arg1 = 0 ;
  LMMCurveState *result = 0 ;
  
  arg1 = (std::vector< Time > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (LMMCurveState *)new LMMCurveState((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_LMMCurveState_setOnForwardRates__SWIG_0(void * jarg1, void * jarg2, unsigned long jarg3) {
  LMMCurveState *arg1 = (LMMCurveState *) 0 ;
  std::vector< Rate > *arg2 = 0 ;
  Size arg3 ;
  
  arg1 = (LMMCurveState *)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return ;
  } 
  arg3 = (Size)jarg3; 
  {
    try {
      (arg1)->setOnForwardRates((std::vector< Rate > 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_LMMCurveState_setOnForwardRates__SWIG_1(void * jarg1, void * jarg2) {
  LMMCurveState *arg1 = (LMMCurveState *) 0 ;
  std::vector< Rate > *arg2 = 0 ;
  
  arg1 = (LMMCurveState *)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->setOnForwardRates((std::vector< Rate > 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_LMMCurveState_setOnDiscountRatios__SWIG_0(void * jarg1, void * jarg2, unsigned long jarg3) {
  LMMCurveState *arg1 = (LMMCurveState *) 0 ;
  std::vector< DiscountFactor > *arg2 = 0 ;
  Size arg3 ;
  
  arg1 = (LMMCurveState *)jarg1; 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return ;
  } 
  arg3 = (Size)jarg3; 
  {
    try {
      (arg1)->setOnDiscountRatios((std::vector< DiscountFactor > 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_LMMCurveState_setOnDiscountRatios__SWIG_1(void * jarg1, void * jarg2) {
  LMMCurveState *arg1 = (LMMCurveState *) 0 ;
  std::vector< DiscountFactor > *arg2 = 0 ;
  
  arg1 = (LMMCurveState *)jarg1; 
  arg2 = (std::vector< DiscountFactor > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< DiscountFactor > const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->setOnDiscountRatios((std::vector< DiscountFactor > 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_LMMCurveState(void * jarg1) {
  LMMCurveState *arg1 = (LMMCurveState *) 0 ;
  
  arg1 = (LMMCurveState *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LMMDriftCalculator(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  Matrix *arg1 = 0 ;
  std::vector< Spread > *arg2 = 0 ;
  std::vector< Time > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  LMMDriftCalculator *result = 0 ;
  
  arg1 = (Matrix *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Spread > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  arg3 = (std::vector< Time > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (LMMDriftCalculator *)new LMMDriftCalculator((Matrix const &)*arg1,(std::vector< Spread > const &)*arg2,(std::vector< Time > 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_LMMDriftCalculator_compute__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  LMMDriftCalculator *arg1 = (LMMDriftCalculator *) 0 ;
  LMMCurveState *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  
  arg1 = (LMMDriftCalculator *)jarg1; 
  arg2 = (LMMCurveState *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LMMCurveState const & is null", 0);
    return ;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > & is null", 0);
    return ;
  } 
  {
    try {
      ((LMMDriftCalculator const *)arg1)->compute((LMMCurveState 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_LMMDriftCalculator_compute__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  LMMDriftCalculator *arg1 = (LMMDriftCalculator *) 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  
  arg1 = (LMMDriftCalculator *)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return ;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > & is null", 0);
    return ;
  } 
  {
    try {
      ((LMMDriftCalculator const *)arg1)->compute((std::vector< Rate > 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_LMMDriftCalculator_computePlain__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  LMMDriftCalculator *arg1 = (LMMDriftCalculator *) 0 ;
  LMMCurveState *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  
  arg1 = (LMMDriftCalculator *)jarg1; 
  arg2 = (LMMCurveState *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LMMCurveState const & is null", 0);
    return ;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > & is null", 0);
    return ;
  } 
  {
    try {
      ((LMMDriftCalculator const *)arg1)->computePlain((LMMCurveState 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_LMMDriftCalculator_computePlain__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  LMMDriftCalculator *arg1 = (LMMDriftCalculator *) 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  
  arg1 = (LMMDriftCalculator *)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return ;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > & is null", 0);
    return ;
  } 
  {
    try {
      ((LMMDriftCalculator const *)arg1)->computePlain((std::vector< Rate > 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_LMMDriftCalculator_computeReduced__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  LMMDriftCalculator *arg1 = (LMMDriftCalculator *) 0 ;
  LMMCurveState *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  
  arg1 = (LMMDriftCalculator *)jarg1; 
  arg2 = (LMMCurveState *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LMMCurveState const & is null", 0);
    return ;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > & is null", 0);
    return ;
  } 
  {
    try {
      ((LMMDriftCalculator const *)arg1)->computeReduced((LMMCurveState 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_LMMDriftCalculator_computeReduced__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  LMMDriftCalculator *arg1 = (LMMDriftCalculator *) 0 ;
  std::vector< Rate > *arg2 = 0 ;
  std::vector< Real > *arg3 = 0 ;
  
  arg1 = (LMMDriftCalculator *)jarg1; 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return ;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > & is null", 0);
    return ;
  } 
  {
    try {
      ((LMMDriftCalculator const *)arg1)->computeReduced((std::vector< Rate > 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_delete_LMMDriftCalculator(void * jarg1) {
  LMMDriftCalculator *arg1 = (LMMDriftCalculator *) 0 ;
  
  arg1 = (LMMDriftCalculator *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MarketModelEvolver_numeraires(void * jarg1) {
  void * jresult ;
  MarketModelEvolver *arg1 = (MarketModelEvolver *) 0 ;
  ext::shared_ptr< MarketModelEvolver const > *smartarg1 = 0 ;
  std::vector< unsigned int > result;
  
  
  smartarg1 = (ext::shared_ptr< const MarketModelEvolver > *)jarg1;
  arg1 = (MarketModelEvolver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = MarketModelEvolver_numeraires((MarketModelEvolver const *)arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MarketModelEvolver_startNewPath(void * jarg1) {
  double jresult ;
  MarketModelEvolver *arg1 = (MarketModelEvolver *) 0 ;
  ext::shared_ptr< MarketModelEvolver > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  MarketModelEvolver > *)jarg1;
  arg1 = (MarketModelEvolver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->startNewPath();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_MarketModelEvolver_advanceStep(void * jarg1) {
  double jresult ;
  MarketModelEvolver *arg1 = (MarketModelEvolver *) 0 ;
  ext::shared_ptr< MarketModelEvolver > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  MarketModelEvolver > *)jarg1;
  arg1 = (MarketModelEvolver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->advanceStep();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_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_MarketModelEvolver_currentStep(void * jarg1) {
  unsigned long jresult ;
  MarketModelEvolver *arg1 = (MarketModelEvolver *) 0 ;
  ext::shared_ptr< MarketModelEvolver const > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr< const MarketModelEvolver > *)jarg1;
  arg1 = (MarketModelEvolver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((MarketModelEvolver const *)arg1)->currentStep();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_MarketModelEvolver_currentState(void * jarg1) {
  void * jresult ;
  MarketModelEvolver *arg1 = (MarketModelEvolver *) 0 ;
  ext::shared_ptr< MarketModelEvolver const > *smartarg1 = 0 ;
  CurveState *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const MarketModelEvolver > *)jarg1;
  arg1 = (MarketModelEvolver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (CurveState *) &((MarketModelEvolver const *)arg1)->currentState();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_MarketModelEvolver_setInitialState(void * jarg1, void * jarg2) {
  MarketModelEvolver *arg1 = (MarketModelEvolver *) 0 ;
  CurveState *arg2 = 0 ;
  ext::shared_ptr< MarketModelEvolver > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MarketModelEvolver > *)jarg1;
  arg1 = (MarketModelEvolver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (CurveState *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CurveState const & is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->setInitialState((CurveState 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_MarketModelEvolver(void * jarg1) {
  MarketModelEvolver *arg1 = (MarketModelEvolver *) 0 ;
  ext::shared_ptr< MarketModelEvolver > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  MarketModelEvolver > *)jarg1;
  arg1 = (MarketModelEvolver *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogNormalFwdRateIpc__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< MarketModel > *arg1 = 0 ;
  BrownianGeneratorFactory *arg2 = 0 ;
  std::vector< unsigned int > *arg3 = 0 ;
  Size arg4 ;
  ext::shared_ptr< MarketModel > tempnull1 ;
  LogNormalFwdRateIpc *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< MarketModel > *)jarg1 : &tempnull1; 
  
  arg2 = (BrownianGeneratorFactory *)(((ext::shared_ptr< const BrownianGeneratorFactory > *)jarg2) ? ((ext::shared_ptr< const BrownianGeneratorFactory > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BrownianGeneratorFactory const & reference is null", 0);
    return 0;
  } 
  arg3 = (std::vector< unsigned int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & is null", 0);
    return 0;
  } 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (LogNormalFwdRateIpc *)new_LogNormalFwdRateIpc__SWIG_0((ext::shared_ptr< MarketModel > const &)*arg1,(BrownianGeneratorFactory const &)*arg2,(std::vector< unsigned int > const &)*arg3,SWIG_STD_MOVE(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 ? new ext::shared_ptr<  LogNormalFwdRateIpc >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_LogNormalFwdRateIpc__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< MarketModel > *arg1 = 0 ;
  BrownianGeneratorFactory *arg2 = 0 ;
  std::vector< unsigned int > *arg3 = 0 ;
  ext::shared_ptr< MarketModel > tempnull1 ;
  LogNormalFwdRateIpc *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< MarketModel > *)jarg1 : &tempnull1; 
  
  arg2 = (BrownianGeneratorFactory *)(((ext::shared_ptr< const BrownianGeneratorFactory > *)jarg2) ? ((ext::shared_ptr< const BrownianGeneratorFactory > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "BrownianGeneratorFactory const & reference is null", 0);
    return 0;
  } 
  arg3 = (std::vector< unsigned int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (LogNormalFwdRateIpc *)new_LogNormalFwdRateIpc__SWIG_0((ext::shared_ptr< MarketModel > const &)*arg1,(BrownianGeneratorFactory const &)*arg2,(std::vector< unsigned int > 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 ? new ext::shared_ptr<  LogNormalFwdRateIpc >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LogNormalFwdRateIpc(void * jarg1) {
  LogNormalFwdRateIpc *arg1 = (LogNormalFwdRateIpc *) 0 ;
  ext::shared_ptr< LogNormalFwdRateIpc > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  LogNormalFwdRateIpc > *)jarg1;
  arg1 = (LogNormalFwdRateIpc *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AbcdVol(double jarg1, double jarg2, double jarg3, double jarg4, void * jarg5, void * jarg6, void * jarg7, unsigned long jarg8, void * jarg9, void * jarg10) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  std::vector< Real > *arg5 = 0 ;
  ext::shared_ptr< PiecewiseConstantCorrelation > *arg6 = 0 ;
  EvolutionDescription *arg7 = 0 ;
  Size arg8 ;
  std::vector< Rate > *arg9 = 0 ;
  std::vector< Spread > *arg10 = 0 ;
  ext::shared_ptr< PiecewiseConstantCorrelation > tempnull6 ;
  AbcdVol *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (std::vector< Real > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  arg6 = jarg6 ? (ext::shared_ptr< PiecewiseConstantCorrelation > *)jarg6 : &tempnull6; 
  arg7 = (EvolutionDescription *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "EvolutionDescription const & is null", 0);
    return 0;
  } 
  arg8 = (Size)jarg8; 
  arg9 = (std::vector< Rate > *)jarg9;
  if (!arg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg10 = (std::vector< Spread > *)jarg10;
  if (!arg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Spread > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (AbcdVol *)new AbcdVol(arg1,arg2,arg3,arg4,(std::vector< Real > const &)*arg5,(ext::shared_ptr< PiecewiseConstantCorrelation > const &)*arg6,(EvolutionDescription const &)*arg7,arg8,(std::vector< Rate > const &)*arg9,(std::vector< Spread > 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 = result ? new ext::shared_ptr<  AbcdVol >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AbcdVol(void * jarg1) {
  AbcdVol *arg1 = (AbcdVol *) 0 ;
  ext::shared_ptr< AbcdVol > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AbcdVol > *)jarg1;
  arg1 = (AbcdVol *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AbcdMathFunction__SWIG_0(double jarg1, double jarg2, double jarg3, double jarg4) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  AbcdMathFunction *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (AbcdMathFunction *)new AbcdMathFunction(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_AbcdMathFunction__SWIG_1(double jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  AbcdMathFunction *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (AbcdMathFunction *)new AbcdMathFunction(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_AbcdMathFunction__SWIG_2(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  AbcdMathFunction *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (AbcdMathFunction *)new AbcdMathFunction(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_AbcdMathFunction__SWIG_3(double jarg1) {
  void * jresult ;
  Real arg1 ;
  AbcdMathFunction *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (AbcdMathFunction *)new AbcdMathFunction(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AbcdMathFunction__SWIG_5(void * jarg1) {
  void * jresult ;
  std::vector< Real > arg1 ;
  std::vector< Real > *argp1 ;
  AbcdMathFunction *result = 0 ;
  
  argp1 = (std::vector< Real > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< Real >", 0);
    return 0;
  }
  arg1 = *argp1; 
  {
    try {
      result = (AbcdMathFunction *)new AbcdMathFunction(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_AbcdMathFunction_call(void * jarg1, double jarg2) {
  double jresult ;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (AbcdMathFunction *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)((AbcdMathFunction 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 double SWIGSTDCALL CSharp_QuantLib_AbcdMathFunction_maximumLocation(void * jarg1) {
  double jresult ;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  Time result;
  
  arg1 = (AbcdMathFunction *)jarg1; 
  {
    try {
      result = (Time)((AbcdMathFunction const *)arg1)->maximumLocation();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


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


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


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_AbcdMathFunction_derivative(void * jarg1, double jarg2) {
  double jresult ;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (AbcdMathFunction *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)((AbcdMathFunction const *)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 double SWIGSTDCALL CSharp_QuantLib_AbcdMathFunction_primitive(void * jarg1, double jarg2) {
  double jresult ;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  Time arg2 ;
  Real result;
  
  arg1 = (AbcdMathFunction *)jarg1; 
  arg2 = (Time)jarg2; 
  {
    try {
      result = (Real)((AbcdMathFunction const *)arg1)->primitive(arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_AbcdMathFunction_definiteIntegral(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real result;
  
  arg1 = (AbcdMathFunction *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)((AbcdMathFunction const *)arg1)->definiteIntegral(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_AbcdMathFunction_a(void * jarg1) {
  double jresult ;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  Real result;
  
  arg1 = (AbcdMathFunction *)jarg1; 
  {
    try {
      result = (Real)((AbcdMathFunction const *)arg1)->a();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


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


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


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


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


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AbcdMathFunction_definiteIntegralCoefficients(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  std::vector< Real > result;
  
  arg1 = (AbcdMathFunction *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = ((AbcdMathFunction const *)arg1)->definiteIntegralCoefficients(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 std::vector< Real >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_AbcdMathFunction_definiteDerivativeCoefficients(void * jarg1, double jarg2, double jarg3) {
  void * jresult ;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  std::vector< Real > result;
  
  arg1 = (AbcdMathFunction *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = ((AbcdMathFunction const *)arg1)->definiteDerivativeCoefficients(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 std::vector< Real >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_AbcdMathFunction_validate(double jarg1, double jarg2, double jarg3, double jarg4) {
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      AbcdMathFunction::validate(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_AbcdMathFunction(void * jarg1) {
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  
  arg1 = (AbcdMathFunction *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AbcdFunction__SWIG_0(double jarg1, double jarg2, double jarg3, double jarg4) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  AbcdFunction *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (AbcdFunction *)new AbcdFunction(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_AbcdFunction__SWIG_1(double jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  AbcdFunction *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (AbcdFunction *)new AbcdFunction(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_AbcdFunction__SWIG_2(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  AbcdFunction *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (AbcdFunction *)new AbcdFunction(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_AbcdFunction__SWIG_3(double jarg1) {
  void * jresult ;
  Real arg1 ;
  AbcdFunction *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (AbcdFunction *)new AbcdFunction(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AbcdFunction__SWIG_4() {
  void * jresult ;
  AbcdFunction *result = 0 ;
  
  {
    try {
      result = (AbcdFunction *)new AbcdFunction();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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_AbcdFunction_maximumVolatility(void * jarg1) {
  double jresult ;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Real result;
  
  arg1 = (AbcdFunction *)jarg1; 
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->maximumVolatility();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


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


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


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_AbcdFunction_covariance__SWIG_0(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Time arg4 ;
  Real result;
  
  arg1 = (AbcdFunction *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Time)jarg4; 
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->covariance(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_AbcdFunction_covariance__SWIG_1(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Time arg4 ;
  Time arg5 ;
  Real result;
  
  arg1 = (AbcdFunction *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Time)jarg4; 
  arg5 = (Time)jarg5; 
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->covariance(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_AbcdFunction_volatility(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Time arg4 ;
  Real result;
  
  arg1 = (AbcdFunction *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Time)jarg4; 
  {
    try {
      result = (Real)((AbcdFunction const *)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_AbcdFunction_variance(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Time arg4 ;
  Real result;
  
  arg1 = (AbcdFunction *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Time)jarg4; 
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->variance(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_AbcdFunction_instantaneousVolatility(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real result;
  
  arg1 = (AbcdFunction *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->instantaneousVolatility(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_AbcdFunction_instantaneousVariance(void * jarg1, double jarg2, double jarg3) {
  double jresult ;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real result;
  
  arg1 = (AbcdFunction *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->instantaneousVariance(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_AbcdFunction_instantaneousCovariance(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Time arg4 ;
  Real result;
  
  arg1 = (AbcdFunction *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Time)jarg4; 
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->instantaneousCovariance(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_AbcdFunction_primitive(void * jarg1, double jarg2, double jarg3, double jarg4) {
  double jresult ;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Time arg4 ;
  Real result;
  
  arg1 = (AbcdFunction *)jarg1; 
  arg2 = (Time)jarg2; 
  arg3 = (Time)jarg3; 
  arg4 = (Time)jarg4; 
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->primitive(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_AbcdFunction(void * jarg1) {
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  
  arg1 = (AbcdFunction *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ContinuousFloatingLookbackOption(double jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< TypePayoff > *arg2 = 0 ;
  ext::shared_ptr< Exercise > *arg3 = 0 ;
  ext::shared_ptr< TypePayoff > tempnull2 ;
  ext::shared_ptr< Exercise > tempnull3 ;
  ContinuousFloatingLookbackOption *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< TypePayoff > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< Exercise > *)jarg3 : &tempnull3; 
  {
    try {
      result = (ContinuousFloatingLookbackOption *)new ContinuousFloatingLookbackOption(arg1,(ext::shared_ptr< TypePayoff > const &)*arg2,(ext::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 = result ? new ext::shared_ptr<  ContinuousFloatingLookbackOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ContinuousFloatingLookbackOption(void * jarg1) {
  ContinuousFloatingLookbackOption *arg1 = (ContinuousFloatingLookbackOption *) 0 ;
  ext::shared_ptr< ContinuousFloatingLookbackOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ContinuousFloatingLookbackOption > *)jarg1;
  arg1 = (ContinuousFloatingLookbackOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ContinuousFixedLookbackOption(double jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Real arg1 ;
  ext::shared_ptr< StrikedTypePayoff > *arg2 = 0 ;
  ext::shared_ptr< Exercise > *arg3 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull2 ;
  ext::shared_ptr< Exercise > tempnull3 ;
  ContinuousFixedLookbackOption *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< Exercise > *)jarg3 : &tempnull3; 
  {
    try {
      result = (ContinuousFixedLookbackOption *)new ContinuousFixedLookbackOption(arg1,(ext::shared_ptr< StrikedTypePayoff > const &)*arg2,(ext::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 = result ? new ext::shared_ptr<  ContinuousFixedLookbackOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ContinuousFixedLookbackOption(void * jarg1) {
  ContinuousFixedLookbackOption *arg1 = (ContinuousFixedLookbackOption *) 0 ;
  ext::shared_ptr< ContinuousFixedLookbackOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ContinuousFixedLookbackOption > *)jarg1;
  arg1 = (ContinuousFixedLookbackOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ContinuousPartialFloatingLookbackOption(double jarg1, double jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Date arg3 ;
  ext::shared_ptr< TypePayoff > *arg4 = 0 ;
  ext::shared_ptr< Exercise > *arg5 = 0 ;
  Date *argp3 ;
  ext::shared_ptr< TypePayoff > tempnull4 ;
  ext::shared_ptr< Exercise > tempnull5 ;
  ContinuousPartialFloatingLookbackOption *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  argp3 = (Date *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = jarg4 ? (ext::shared_ptr< TypePayoff > *)jarg4 : &tempnull4; 
  arg5 = jarg5 ? (ext::shared_ptr< Exercise > *)jarg5 : &tempnull5; 
  {
    try {
      result = (ContinuousPartialFloatingLookbackOption *)new ContinuousPartialFloatingLookbackOption(arg1,arg2,arg3,(ext::shared_ptr< TypePayoff > const &)*arg4,(ext::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 = result ? new ext::shared_ptr<  ContinuousPartialFloatingLookbackOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ContinuousPartialFloatingLookbackOption(void * jarg1) {
  ContinuousPartialFloatingLookbackOption *arg1 = (ContinuousPartialFloatingLookbackOption *) 0 ;
  ext::shared_ptr< ContinuousPartialFloatingLookbackOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ContinuousPartialFloatingLookbackOption > *)jarg1;
  arg1 = (ContinuousPartialFloatingLookbackOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_ContinuousPartialFixedLookbackOption(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Date arg1 ;
  ext::shared_ptr< StrikedTypePayoff > *arg2 = 0 ;
  ext::shared_ptr< Exercise > *arg3 = 0 ;
  Date *argp1 ;
  ext::shared_ptr< StrikedTypePayoff > tempnull2 ;
  ext::shared_ptr< Exercise > tempnull3 ;
  ContinuousPartialFixedLookbackOption *result = 0 ;
  
  argp1 = (Date *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Date", 0);
    return 0;
  }
  arg1 = *argp1; 
  arg2 = jarg2 ? (ext::shared_ptr< StrikedTypePayoff > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< Exercise > *)jarg3 : &tempnull3; 
  {
    try {
      result = (ContinuousPartialFixedLookbackOption *)new ContinuousPartialFixedLookbackOption(arg1,(ext::shared_ptr< StrikedTypePayoff > const &)*arg2,(ext::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 = result ? new ext::shared_ptr<  ContinuousPartialFixedLookbackOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ContinuousPartialFixedLookbackOption(void * jarg1) {
  ContinuousPartialFixedLookbackOption *arg1 = (ContinuousPartialFixedLookbackOption *) 0 ;
  ext::shared_ptr< ContinuousPartialFixedLookbackOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  ContinuousPartialFixedLookbackOption > *)jarg1;
  arg1 = (ContinuousPartialFixedLookbackOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticContinuousFloatingLookbackEngine(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticContinuousFloatingLookbackEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticContinuousFloatingLookbackEngine *)new AnalyticContinuousFloatingLookbackEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticContinuousFloatingLookbackEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticContinuousFloatingLookbackEngine(void * jarg1) {
  AnalyticContinuousFloatingLookbackEngine *arg1 = (AnalyticContinuousFloatingLookbackEngine *) 0 ;
  ext::shared_ptr< AnalyticContinuousFloatingLookbackEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticContinuousFloatingLookbackEngine > *)jarg1;
  arg1 = (AnalyticContinuousFloatingLookbackEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticContinuousFixedLookbackEngine(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticContinuousFixedLookbackEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticContinuousFixedLookbackEngine *)new AnalyticContinuousFixedLookbackEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticContinuousFixedLookbackEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticContinuousFixedLookbackEngine(void * jarg1) {
  AnalyticContinuousFixedLookbackEngine *arg1 = (AnalyticContinuousFixedLookbackEngine *) 0 ;
  ext::shared_ptr< AnalyticContinuousFixedLookbackEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticContinuousFixedLookbackEngine > *)jarg1;
  arg1 = (AnalyticContinuousFixedLookbackEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticContinuousPartialFloatingLookbackEngine(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticContinuousPartialFloatingLookbackEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticContinuousPartialFloatingLookbackEngine *)new AnalyticContinuousPartialFloatingLookbackEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticContinuousPartialFloatingLookbackEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticContinuousPartialFloatingLookbackEngine(void * jarg1) {
  AnalyticContinuousPartialFloatingLookbackEngine *arg1 = (AnalyticContinuousPartialFloatingLookbackEngine *) 0 ;
  ext::shared_ptr< AnalyticContinuousPartialFloatingLookbackEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticContinuousPartialFloatingLookbackEngine > *)jarg1;
  arg1 = (AnalyticContinuousPartialFloatingLookbackEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_AnalyticContinuousPartialFixedLookbackEngine(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  AnalyticContinuousPartialFixedLookbackEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (AnalyticContinuousPartialFixedLookbackEngine *)new AnalyticContinuousPartialFixedLookbackEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  AnalyticContinuousPartialFixedLookbackEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_AnalyticContinuousPartialFixedLookbackEngine(void * jarg1) {
  AnalyticContinuousPartialFixedLookbackEngine *arg1 = (AnalyticContinuousPartialFixedLookbackEngine *) 0 ;
  ext::shared_ptr< AnalyticContinuousPartialFixedLookbackEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  AnalyticContinuousPartialFixedLookbackEngine > *)jarg1;
  arg1 = (AnalyticContinuousPartialFixedLookbackEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 & is null", 0);
    return 0;
  } 
  arg2 = (Matrix *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & 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(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 ;
  Path *result = 0 ;
  
  arg1 = (Sample< Path > *)jarg1; 
  {
    try {
      result = (Path *) &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 = (void *)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__SWIG_0(void * jarg1, double jarg2, unsigned long jarg3, void * jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  Time arg2 ;
  Size arg3 ;
  GaussianRandomSequenceGenerator *arg4 = 0 ;
  bool arg5 ;
  ext::shared_ptr< StochasticProcess > tempnull1 ;
  PathGenerator< GaussianRandomSequenceGenerator > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess > *)jarg1 : &tempnull1; 
  arg2 = (Time)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (GaussianRandomSequenceGenerator *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GaussianRandomSequenceGenerator const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (PathGenerator< GaussianRandomSequenceGenerator > *)new PathGenerator< GaussianRandomSequenceGenerator >((ext::shared_ptr< StochasticProcess > 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_new_GaussianPathGenerator__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  GaussianRandomSequenceGenerator *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< StochasticProcess > tempnull1 ;
  PathGenerator< GaussianRandomSequenceGenerator > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess > *)jarg1 : &tempnull1; 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & is null", 0);
    return 0;
  } 
  arg3 = (GaussianRandomSequenceGenerator *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GaussianRandomSequenceGenerator const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (PathGenerator< GaussianRandomSequenceGenerator > *)new PathGenerator< GaussianRandomSequenceGenerator >((ext::shared_ptr< StochasticProcess > const &)*arg1,(TimeGrid 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_GaussianPathGenerator_next(void * jarg1) {
  void * jresult ;
  PathGenerator< GaussianRandomSequenceGenerator > *arg1 = (PathGenerator< GaussianRandomSequenceGenerator > *) 0 ;
  PathGenerator< GaussianRandomSequenceGenerator >::sample_type *result = 0 ;
  
  arg1 = (PathGenerator< GaussianRandomSequenceGenerator > *)jarg1; 
  {
    try {
      result = (PathGenerator< GaussianRandomSequenceGenerator >::sample_type *) &((PathGenerator< GaussianRandomSequenceGenerator > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GaussianPathGenerator_antithetic(void * jarg1) {
  void * jresult ;
  PathGenerator< GaussianRandomSequenceGenerator > *arg1 = (PathGenerator< GaussianRandomSequenceGenerator > *) 0 ;
  PathGenerator< GaussianRandomSequenceGenerator >::sample_type *result = 0 ;
  
  arg1 = (PathGenerator< GaussianRandomSequenceGenerator > *)jarg1; 
  {
    try {
      result = (PathGenerator< GaussianRandomSequenceGenerator >::sample_type *) &((PathGenerator< GaussianRandomSequenceGenerator > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_GaussianPathGenerator_size(void * jarg1) {
  unsigned long jresult ;
  PathGenerator< GaussianRandomSequenceGenerator > *arg1 = (PathGenerator< GaussianRandomSequenceGenerator > *) 0 ;
  Size result;
  
  arg1 = (PathGenerator< GaussianRandomSequenceGenerator > *)jarg1; 
  {
    try {
      result = ((PathGenerator< GaussianRandomSequenceGenerator > 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_GaussianPathGenerator_timeGrid(void * jarg1) {
  void * jresult ;
  PathGenerator< GaussianRandomSequenceGenerator > *arg1 = (PathGenerator< GaussianRandomSequenceGenerator > *) 0 ;
  TimeGrid *result = 0 ;
  
  arg1 = (PathGenerator< GaussianRandomSequenceGenerator > *)jarg1; 
  {
    try {
      result = (TimeGrid *) &((PathGenerator< GaussianRandomSequenceGenerator > const *)arg1)->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_delete_GaussianPathGenerator(void * jarg1) {
  PathGenerator< GaussianRandomSequenceGenerator > *arg1 = (PathGenerator< GaussianRandomSequenceGenerator > *) 0 ;
  
  arg1 = (PathGenerator< 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_GaussianSobolPathGenerator__SWIG_0(void * jarg1, double jarg2, unsigned long jarg3, void * jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  Time arg2 ;
  Size arg3 ;
  GaussianLowDiscrepancySequenceGenerator *arg4 = 0 ;
  bool arg5 ;
  ext::shared_ptr< StochasticProcess > tempnull1 ;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess > *)jarg1 : &tempnull1; 
  arg2 = (Time)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (GaussianLowDiscrepancySequenceGenerator *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GaussianLowDiscrepancySequenceGenerator const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *)new PathGenerator< GaussianLowDiscrepancySequenceGenerator >((ext::shared_ptr< StochasticProcess > 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_new_GaussianSobolPathGenerator__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  GaussianLowDiscrepancySequenceGenerator *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< StochasticProcess > tempnull1 ;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess > *)jarg1 : &tempnull1; 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & is null", 0);
    return 0;
  } 
  arg3 = (GaussianLowDiscrepancySequenceGenerator *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GaussianLowDiscrepancySequenceGenerator const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *)new PathGenerator< GaussianLowDiscrepancySequenceGenerator >((ext::shared_ptr< StochasticProcess > const &)*arg1,(TimeGrid const &)*arg2,(GaussianLowDiscrepancySequenceGenerator 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_GaussianSobolPathGenerator_next(void * jarg1) {
  void * jresult ;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator > *arg1 = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *) 0 ;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *result = 0 ;
  
  arg1 = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *)jarg1; 
  {
    try {
      result = (PathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *) &((PathGenerator< GaussianLowDiscrepancySequenceGenerator > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GaussianSobolPathGenerator_antithetic(void * jarg1) {
  void * jresult ;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator > *arg1 = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *) 0 ;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *result = 0 ;
  
  arg1 = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *)jarg1; 
  {
    try {
      result = (PathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *) &((PathGenerator< GaussianLowDiscrepancySequenceGenerator > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_GaussianSobolPathGenerator_size(void * jarg1) {
  unsigned long jresult ;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator > *arg1 = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *) 0 ;
  Size result;
  
  arg1 = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *)jarg1; 
  {
    try {
      result = ((PathGenerator< GaussianLowDiscrepancySequenceGenerator > 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_GaussianSobolPathGenerator_timeGrid(void * jarg1) {
  void * jresult ;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator > *arg1 = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *) 0 ;
  TimeGrid *result = 0 ;
  
  arg1 = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *)jarg1; 
  {
    try {
      result = (TimeGrid *) &((PathGenerator< GaussianLowDiscrepancySequenceGenerator > const *)arg1)->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_delete_GaussianSobolPathGenerator(void * jarg1) {
  PathGenerator< GaussianLowDiscrepancySequenceGenerator > *arg1 = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *) 0 ;
  
  arg1 = (PathGenerator< 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_new_InvCumulativeMersenneTwisterPathGenerator__SWIG_0(void * jarg1, double jarg2, unsigned long jarg3, void * jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  Time arg2 ;
  Size arg3 ;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *arg4 = 0 ;
  bool arg5 ;
  ext::shared_ptr< StochasticProcess > tempnull1 ;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess > *)jarg1 : &tempnull1; 
  arg2 = (Time)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *)new PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > >((ext::shared_ptr< StochasticProcess > const &)*arg1,arg2,arg3,(InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > 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_InvCumulativeMersenneTwisterPathGenerator__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< StochasticProcess > tempnull1 ;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess > *)jarg1 : &tempnull1; 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & is null", 0);
    return 0;
  } 
  arg3 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *)new PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > >((ext::shared_ptr< StochasticProcess > const &)*arg1,(TimeGrid const &)*arg2,(InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > 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_InvCumulativeMersenneTwisterPathGenerator_next(void * jarg1) {
  void * jresult ;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *arg1 = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *) 0 ;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > >::sample_type *result = 0 ;
  
  arg1 = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *)jarg1; 
  {
    try {
      result = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > >::sample_type *) &((PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_InvCumulativeMersenneTwisterPathGenerator_antithetic(void * jarg1) {
  void * jresult ;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *arg1 = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *) 0 ;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > >::sample_type *result = 0 ;
  
  arg1 = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *)jarg1; 
  {
    try {
      result = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > >::sample_type *) &((PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_QuantLib_InvCumulativeMersenneTwisterPathGenerator_size(void * jarg1) {
  unsigned long jresult ;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *arg1 = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *) 0 ;
  Size result;
  
  arg1 = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *)jarg1; 
  {
    try {
      result = ((PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > 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_InvCumulativeMersenneTwisterPathGenerator_timeGrid(void * jarg1) {
  void * jresult ;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *arg1 = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *) 0 ;
  TimeGrid *result = 0 ;
  
  arg1 = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *)jarg1; 
  {
    try {
      result = (TimeGrid *) &((PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > const *)arg1)->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_delete_InvCumulativeMersenneTwisterPathGenerator(void * jarg1) {
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *arg1 = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *) 0 ;
  
  arg1 = (PathGenerator< 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 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 ;
  MultiPath *result = 0 ;
  
  arg1 = (Sample< MultiPath > *)jarg1; 
  {
    try {
      result = (MultiPath *) &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 = (void *)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 ;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  GaussianRandomSequenceGenerator *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< StochasticProcess > tempnull1 ;
  MultiPathGenerator< GaussianRandomSequenceGenerator > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess > *)jarg1 : &tempnull1; 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & is null", 0);
    return 0;
  } 
  arg3 = (GaussianRandomSequenceGenerator *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GaussianRandomSequenceGenerator const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MultiPathGenerator< GaussianRandomSequenceGenerator > *)new MultiPathGenerator< GaussianRandomSequenceGenerator >((ext::shared_ptr< StochasticProcess > const &)*arg1,(TimeGrid 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 ;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  GaussianRandomSequenceGenerator *arg3 = 0 ;
  ext::shared_ptr< StochasticProcess > tempnull1 ;
  MultiPathGenerator< GaussianRandomSequenceGenerator > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess > *)jarg1 : &tempnull1; 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & is null", 0);
    return 0;
  } 
  arg3 = (GaussianRandomSequenceGenerator *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GaussianRandomSequenceGenerator const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MultiPathGenerator< GaussianRandomSequenceGenerator > *)new MultiPathGenerator< GaussianRandomSequenceGenerator >((ext::shared_ptr< StochasticProcess > const &)*arg1,(TimeGrid 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_new_GaussianMultiPathGenerator__SWIG_2(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  std::vector< Time > *arg2 = 0 ;
  GaussianRandomSequenceGenerator *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< StochasticProcess > tempnull1 ;
  MultiPathGenerator< GaussianRandomSequenceGenerator > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess > *)jarg1 : &tempnull1; 
  arg2 = (std::vector< Time > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg3 = (GaussianRandomSequenceGenerator *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GaussianRandomSequenceGenerator const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MultiPathGenerator< GaussianRandomSequenceGenerator > *)new_MultiPathGenerator_Sl_GaussianRandomSequenceGenerator_Sg___SWIG_2((ext::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_3(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  std::vector< Time > *arg2 = 0 ;
  GaussianRandomSequenceGenerator *arg3 = 0 ;
  ext::shared_ptr< StochasticProcess > tempnull1 ;
  MultiPathGenerator< GaussianRandomSequenceGenerator > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess > *)jarg1 : &tempnull1; 
  arg2 = (std::vector< Time > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg3 = (GaussianRandomSequenceGenerator *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GaussianRandomSequenceGenerator const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MultiPathGenerator< GaussianRandomSequenceGenerator > *)new_MultiPathGenerator_Sl_GaussianRandomSequenceGenerator_Sg___SWIG_2((ext::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 ;
  MultiPathGenerator< GaussianRandomSequenceGenerator > *arg1 = (MultiPathGenerator< GaussianRandomSequenceGenerator > *) 0 ;
  MultiPathGenerator< GaussianRandomSequenceGenerator >::sample_type *result = 0 ;
  
  arg1 = (MultiPathGenerator< GaussianRandomSequenceGenerator > *)jarg1; 
  {
    try {
      result = (MultiPathGenerator< GaussianRandomSequenceGenerator >::sample_type *) &((MultiPathGenerator< GaussianRandomSequenceGenerator > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GaussianMultiPathGenerator_antithetic(void * jarg1) {
  void * jresult ;
  MultiPathGenerator< GaussianRandomSequenceGenerator > *arg1 = (MultiPathGenerator< GaussianRandomSequenceGenerator > *) 0 ;
  MultiPathGenerator< GaussianRandomSequenceGenerator >::sample_type *result = 0 ;
  
  arg1 = (MultiPathGenerator< GaussianRandomSequenceGenerator > *)jarg1; 
  {
    try {
      result = (MultiPathGenerator< GaussianRandomSequenceGenerator >::sample_type *) &((MultiPathGenerator< GaussianRandomSequenceGenerator > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussianMultiPathGenerator(void * jarg1) {
  MultiPathGenerator< GaussianRandomSequenceGenerator > *arg1 = (MultiPathGenerator< GaussianRandomSequenceGenerator > *) 0 ;
  
  arg1 = (MultiPathGenerator< 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_GaussianSobolMultiPathGenerator__SWIG_0(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  GaussianLowDiscrepancySequenceGenerator *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< StochasticProcess > tempnull1 ;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess > *)jarg1 : &tempnull1; 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & is null", 0);
    return 0;
  } 
  arg3 = (GaussianLowDiscrepancySequenceGenerator *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GaussianLowDiscrepancySequenceGenerator const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *)new MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator >((ext::shared_ptr< StochasticProcess > const &)*arg1,(TimeGrid const &)*arg2,(GaussianLowDiscrepancySequenceGenerator 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_GaussianSobolMultiPathGenerator__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  GaussianLowDiscrepancySequenceGenerator *arg3 = 0 ;
  ext::shared_ptr< StochasticProcess > tempnull1 ;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess > *)jarg1 : &tempnull1; 
  arg2 = (TimeGrid *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "TimeGrid const & is null", 0);
    return 0;
  } 
  arg3 = (GaussianLowDiscrepancySequenceGenerator *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GaussianLowDiscrepancySequenceGenerator const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *)new MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator >((ext::shared_ptr< StochasticProcess > const &)*arg1,(TimeGrid const &)*arg2,(GaussianLowDiscrepancySequenceGenerator 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_GaussianSobolMultiPathGenerator__SWIG_2(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  std::vector< Time > *arg2 = 0 ;
  GaussianLowDiscrepancySequenceGenerator *arg3 = 0 ;
  bool arg4 ;
  ext::shared_ptr< StochasticProcess > tempnull1 ;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess > *)jarg1 : &tempnull1; 
  arg2 = (std::vector< Time > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg3 = (GaussianLowDiscrepancySequenceGenerator *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GaussianLowDiscrepancySequenceGenerator const & is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *)new_MultiPathGenerator_Sl_GaussianLowDiscrepancySequenceGenerator_Sg___SWIG_2((ext::shared_ptr< StochasticProcess > const &)*arg1,(std::vector< double > const &)*arg2,(GaussianLowDiscrepancySequenceGenerator 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_GaussianSobolMultiPathGenerator__SWIG_3(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  std::vector< Time > *arg2 = 0 ;
  GaussianLowDiscrepancySequenceGenerator *arg3 = 0 ;
  ext::shared_ptr< StochasticProcess > tempnull1 ;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StochasticProcess > *)jarg1 : &tempnull1; 
  arg2 = (std::vector< Time > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Time > const & is null", 0);
    return 0;
  } 
  arg3 = (GaussianLowDiscrepancySequenceGenerator *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "GaussianLowDiscrepancySequenceGenerator const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *)new_MultiPathGenerator_Sl_GaussianLowDiscrepancySequenceGenerator_Sg___SWIG_2((ext::shared_ptr< StochasticProcess > const &)*arg1,(std::vector< double > const &)*arg2,(GaussianLowDiscrepancySequenceGenerator 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_GaussianSobolMultiPathGenerator_next(void * jarg1) {
  void * jresult ;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *arg1 = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *) 0 ;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *result = 0 ;
  
  arg1 = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *)jarg1; 
  {
    try {
      result = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *) &((MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_GaussianSobolMultiPathGenerator_antithetic(void * jarg1) {
  void * jresult ;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *arg1 = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *) 0 ;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *result = 0 ;
  
  arg1 = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *)jarg1; 
  {
    try {
      result = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *) &((MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_GaussianSobolMultiPathGenerator(void * jarg1) {
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *arg1 = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *) 0 ;
  
  arg1 = (MultiPathGenerator< 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_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 & 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 & 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 >(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 >(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 >(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 >(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 & 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 >(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 >(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 >(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 >(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_OdeFctDelegate(void * jarg1) {
  OdeFctDelegate *arg1 = (OdeFctDelegate *) 0 ;
  
  arg1 = (OdeFctDelegate *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OdeFctDelegate_value(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  OdeFctDelegate *arg1 = (OdeFctDelegate *) 0 ;
  Real arg2 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Real > result;
  
  arg1 = (OdeFctDelegate *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((OdeFctDelegate const *)arg1)->value(arg2,(std::vector< Real > 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 std::vector< Real >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OdeFctDelegate_valueSwigExplicitOdeFctDelegate(void * jarg1, double jarg2, void * jarg3) {
  void * jresult ;
  OdeFctDelegate *arg1 = (OdeFctDelegate *) 0 ;
  Real arg2 ;
  std::vector< Real > *arg3 = 0 ;
  std::vector< Real > result;
  
  arg1 = (OdeFctDelegate *)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = ((OdeFctDelegate const *)arg1)->OdeFctDelegate::value(arg2,(std::vector< Real > 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 std::vector< Real >(result); 
  return jresult;
}


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


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_OdeFctDelegate_director_connect(void *objarg, SwigDirector_OdeFctDelegate::SWIG_Callback0_t callback0) {
  OdeFctDelegate *obj = (OdeFctDelegate *)objarg;
  SwigDirector_OdeFctDelegate *director = static_cast<SwigDirector_OdeFctDelegate *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RungeKutta__SWIG_0(double jarg1, double jarg2, double jarg3) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  AdaptiveRungeKutta< Real > *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (AdaptiveRungeKutta< Real > *)new AdaptiveRungeKutta< Real >(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_RungeKutta__SWIG_1(double jarg1, double jarg2) {
  void * jresult ;
  Real arg1 ;
  Real arg2 ;
  AdaptiveRungeKutta< Real > *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (Real)jarg2; 
  {
    try {
      result = (AdaptiveRungeKutta< Real > *)new AdaptiveRungeKutta< Real >(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_RungeKutta__SWIG_2(double jarg1) {
  void * jresult ;
  Real arg1 ;
  AdaptiveRungeKutta< Real > *result = 0 ;
  
  arg1 = (Real)jarg1; 
  {
    try {
      result = (AdaptiveRungeKutta< Real > *)new AdaptiveRungeKutta< Real >(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_RungeKutta__SWIG_3() {
  void * jresult ;
  AdaptiveRungeKutta< Real > *result = 0 ;
  
  {
    try {
      result = (AdaptiveRungeKutta< Real > *)new AdaptiveRungeKutta< 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 double SWIGSTDCALL CSharp_QuantLib_RungeKutta_call__SWIG_0(void * jarg1, void * jarg2, double jarg3, double jarg4, double jarg5) {
  double jresult ;
  AdaptiveRungeKutta< Real > *arg1 = (AdaptiveRungeKutta< Real > *) 0 ;
  BinaryFunctionDelegate *arg2 = (BinaryFunctionDelegate *) 0 ;
  double arg3 ;
  Real arg4 ;
  Real arg5 ;
  double result;
  
  arg1 = (AdaptiveRungeKutta< Real > *)jarg1; 
  arg2 = (BinaryFunctionDelegate *)jarg2; 
  arg3 = (double)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (double)AdaptiveRungeKutta_Sl_Real_Sg__operator_Sp__SP___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 void * SWIGSTDCALL CSharp_QuantLib_RungeKutta_call__SWIG_1(void * jarg1, void * jarg2, void * jarg3, double jarg4, double jarg5) {
  void * jresult ;
  AdaptiveRungeKutta< Real > *arg1 = (AdaptiveRungeKutta< Real > *) 0 ;
  OdeFctDelegate *arg2 = (OdeFctDelegate *) 0 ;
  std::vector< double > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  std::vector< double > result;
  
  arg1 = (AdaptiveRungeKutta< Real > *)jarg1; 
  arg2 = (OdeFctDelegate *)jarg2; 
  arg3 = (std::vector< double > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = AdaptiveRungeKutta_Sl_Real_Sg__operator_Sp__SP___SWIG_1(arg1,arg2,(std::vector< double > 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 std::vector< double >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_RungeKutta(void * jarg1) {
  AdaptiveRungeKutta< Real > *arg1 = (AdaptiveRungeKutta< Real > *) 0 ;
  
  arg1 = (AdaptiveRungeKutta< 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_delete_DefaultBoundaryCondition(void * jarg1) {
  DefaultBoundaryCondition *arg1 = (DefaultBoundaryCondition *) 0 ;
  ext::shared_ptr< DefaultBoundaryCondition > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DefaultBoundaryCondition > *)jarg1;
  arg1 = (DefaultBoundaryCondition *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  NeumannBC *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (DefaultBoundaryCondition::Side)jarg2; 
  {
    try {
      result = (NeumannBC *)new NeumannBC(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 ? new ext::shared_ptr<  NeumannBC >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NeumannBC(void * jarg1) {
  NeumannBC *arg1 = (NeumannBC *) 0 ;
  ext::shared_ptr< NeumannBC > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  NeumannBC > *)jarg1;
  arg1 = (NeumannBC *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  DirichletBC *result = 0 ;
  
  arg1 = (Real)jarg1; 
  arg2 = (DefaultBoundaryCondition::Side)jarg2; 
  {
    try {
      result = (DirichletBC *)new DirichletBC(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 ? new ext::shared_ptr<  DirichletBC >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_DirichletBC(void * jarg1) {
  DirichletBC *arg1 = (DirichletBC *) 0 ;
  ext::shared_ptr< DirichletBC > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  DirichletBC > *)jarg1;
  arg1 = (DirichletBC *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 & is null", 0);
    return 0;
  } 
  arg2 = (Array *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & is null", 0);
    return 0;
  } 
  arg3 = (Array *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Array const & 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 & 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(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 & 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(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(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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(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_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 & 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 & 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 & 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 & 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 & 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_new_HestonSLVProcess__SWIG_0(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull2 ;
  HestonSLVProcess *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Real)jarg3; 
  {
    try {
      result = (HestonSLVProcess *)new HestonSLVProcess((ext::shared_ptr< HestonProcess > const &)*arg1,(ext::shared_ptr< LocalVolTermStructure > 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 ? new ext::shared_ptr<  HestonSLVProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HestonSLVProcess__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg2 = 0 ;
  ext::shared_ptr< HestonProcess > tempnull1 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull2 ;
  HestonSLVProcess *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< HestonProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg2 : &tempnull2; 
  {
    try {
      result = (HestonSLVProcess *)new HestonSLVProcess((ext::shared_ptr< HestonProcess > const &)*arg1,(ext::shared_ptr< LocalVolTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  HestonSLVProcess >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HestonSLVProcess(void * jarg1) {
  HestonSLVProcess *arg1 = (HestonSLVProcess *) 0 ;
  ext::shared_ptr< HestonSLVProcess > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  HestonSLVProcess > *)jarg1;
  arg1 = (HestonSLVProcess *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HestonSLVMCModel__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, void * jarg8, double jarg9) {
  void * jresult ;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  std::vector< Date > *arg8 = 0 ;
  Real arg9 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull1 ;
  ext::shared_ptr< HestonModel > tempnull2 ;
  ext::shared_ptr< BrownianGeneratorFactory > tempnull3 ;
  HestonSLVMCModel *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonModel > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< BrownianGeneratorFactory > *)jarg3 : &tempnull3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (std::vector< Date > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg9 = (Real)jarg9; 
  {
    try {
      result = (HestonSLVMCModel *)new_HestonSLVMCModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(ext::shared_ptr< BrownianGeneratorFactory > const &)*arg3,(Date const &)*arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),(std::vector< Date > 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_HestonSLVMCModel__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7, void * jarg8) {
  void * jresult ;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  std::vector< Date > *arg8 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull1 ;
  ext::shared_ptr< HestonModel > tempnull2 ;
  ext::shared_ptr< BrownianGeneratorFactory > tempnull3 ;
  HestonSLVMCModel *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonModel > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< BrownianGeneratorFactory > *)jarg3 : &tempnull3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (std::vector< Date > *)jarg8;
  if (!arg8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (HestonSLVMCModel *)new_HestonSLVMCModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(ext::shared_ptr< BrownianGeneratorFactory > const &)*arg3,(Date const &)*arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),(std::vector< 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_HestonSLVMCModel__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5, unsigned long jarg6, unsigned long jarg7) {
  void * jresult ;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull1 ;
  ext::shared_ptr< HestonModel > tempnull2 ;
  ext::shared_ptr< BrownianGeneratorFactory > tempnull3 ;
  HestonSLVMCModel *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonModel > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< BrownianGeneratorFactory > *)jarg3 : &tempnull3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  {
    try {
      result = (HestonSLVMCModel *)new_HestonSLVMCModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(ext::shared_ptr< BrownianGeneratorFactory > const &)*arg3,(Date const &)*arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(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_HestonSLVMCModel__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5, unsigned long jarg6) {
  void * jresult ;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull1 ;
  ext::shared_ptr< HestonModel > tempnull2 ;
  ext::shared_ptr< BrownianGeneratorFactory > tempnull3 ;
  HestonSLVMCModel *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonModel > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< BrownianGeneratorFactory > *)jarg3 : &tempnull3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Size)jarg5; 
  arg6 = (Size)jarg6; 
  {
    try {
      result = (HestonSLVMCModel *)new_HestonSLVMCModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(ext::shared_ptr< BrownianGeneratorFactory > const &)*arg3,(Date const &)*arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(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_HestonSLVMCModel__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Size arg5 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull1 ;
  ext::shared_ptr< HestonModel > tempnull2 ;
  ext::shared_ptr< BrownianGeneratorFactory > tempnull3 ;
  HestonSLVMCModel *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonModel > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< BrownianGeneratorFactory > *)jarg3 : &tempnull3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (HestonSLVMCModel *)new_HestonSLVMCModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(ext::shared_ptr< BrownianGeneratorFactory > const &)*arg3,(Date const &)*arg4,SWIG_STD_MOVE(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_HestonSLVMCModel__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull1 ;
  ext::shared_ptr< HestonModel > tempnull2 ;
  ext::shared_ptr< BrownianGeneratorFactory > tempnull3 ;
  HestonSLVMCModel *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonModel > *)jarg2 : &tempnull2; 
  arg3 = jarg3 ? (ext::shared_ptr< BrownianGeneratorFactory > *)jarg3 : &tempnull3; 
  arg4 = (Date *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (HestonSLVMCModel *)new_HestonSLVMCModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(ext::shared_ptr< BrownianGeneratorFactory > 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_HestonSLVMCModel_hestonProcess(void * jarg1) {
  void * jresult ;
  HestonSLVMCModel *arg1 = (HestonSLVMCModel *) 0 ;
  ext::shared_ptr< HestonProcess > result;
  
  arg1 = (HestonSLVMCModel *)jarg1; 
  {
    try {
      result = ((HestonSLVMCModel const *)arg1)->hestonProcess();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< HestonProcess >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HestonSLVMCModel_localVol(void * jarg1) {
  void * jresult ;
  HestonSLVMCModel *arg1 = (HestonSLVMCModel *) 0 ;
  ext::shared_ptr< LocalVolTermStructure > result;
  
  arg1 = (HestonSLVMCModel *)jarg1; 
  {
    try {
      result = ((HestonSLVMCModel const *)arg1)->localVol();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< LocalVolTermStructure >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HestonSLVMCModel_leverageFunction(void * jarg1) {
  void * jresult ;
  HestonSLVMCModel *arg1 = (HestonSLVMCModel *) 0 ;
  ext::shared_ptr< LocalVolTermStructure > result;
  
  arg1 = (HestonSLVMCModel *)jarg1; 
  {
    try {
      result = ((HestonSLVMCModel const *)arg1)->leverageFunction();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< LocalVolTermStructure >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_HestonSLVMCModel(void * jarg1) {
  HestonSLVMCModel *arg1 = (HestonSLVMCModel *) 0 ;
  
  arg1 = (HestonSLVMCModel *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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_FdmHestonGreensFct(void * jarg1) {
  FdmHestonGreensFct *arg1 = (FdmHestonGreensFct *) 0 ;
  
  arg1 = (FdmHestonGreensFct *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HestonSLVFokkerPlanckFdmParams(unsigned long jarg1, unsigned long jarg2, unsigned long jarg3, unsigned long jarg4, double jarg5, unsigned long jarg6, unsigned long jarg7, double jarg8, double jarg9, unsigned long jarg10, double jarg11, double jarg12, double jarg13, double jarg14, double jarg15, double jarg16, double jarg17, int jarg18, int jarg19, void * jarg20) {
  void * jresult ;
  Size arg1 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Real arg5 ;
  Size arg6 ;
  Size arg7 ;
  Real arg8 ;
  Real arg9 ;
  Size arg10 ;
  Real arg11 ;
  Real arg12 ;
  Real arg13 ;
  Real arg14 ;
  Real arg15 ;
  Real arg16 ;
  Real arg17 ;
  FdmHestonGreensFct::Algorithm arg18 ;
  FdmSquareRootFwdOp::TransformationType arg19 ;
  SwigValueWrapper< FdmSchemeDesc > arg20 ;
  FdmSchemeDesc *argp20 ;
  HestonSLVFokkerPlanckFdmParams *result = 0 ;
  
  arg1 = (Size)jarg1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Size)jarg6; 
  arg7 = (Size)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = (Real)jarg9; 
  arg10 = (Size)jarg10; 
  arg11 = (Real)jarg11; 
  arg12 = (Real)jarg12; 
  arg13 = (Real)jarg13; 
  arg14 = (Real)jarg14; 
  arg15 = (Real)jarg15; 
  arg16 = (Real)jarg16; 
  arg17 = (Real)jarg17; 
  arg18 = (FdmHestonGreensFct::Algorithm)jarg18; 
  arg19 = (FdmSquareRootFwdOp::TransformationType)jarg19; 
  argp20 = (FdmSchemeDesc *)jarg20; 
  if (!argp20) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null FdmSchemeDesc", 0);
    return 0;
  }
  arg20 = *argp20; 
  {
    try {
      result = (HestonSLVFokkerPlanckFdmParams *)new_HestonSLVFokkerPlanckFdmParams(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),arg8,arg9,SWIG_STD_MOVE(arg10),arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,SWIG_STD_MOVE(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_delete_HestonSLVFokkerPlanckFdmParams(void * jarg1) {
  HestonSLVFokkerPlanckFdmParams *arg1 = (HestonSLVFokkerPlanckFdmParams *) 0 ;
  
  arg1 = (HestonSLVFokkerPlanckFdmParams *)jarg1; 
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_HestonSLVFDMModel__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6, double jarg7) {
  void * jresult ;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  Date *arg3 = 0 ;
  HestonSLVFokkerPlanckFdmParams *arg4 = 0 ;
  bool arg5 ;
  std::vector< Date > *arg6 = 0 ;
  Real arg7 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull1 ;
  ext::shared_ptr< HestonModel > tempnull2 ;
  HestonSLVFDMModel *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonModel > *)jarg2 : &tempnull2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (HestonSLVFokkerPlanckFdmParams *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "HestonSLVFokkerPlanckFdmParams const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg7 = (Real)jarg7; 
  {
    try {
      result = (HestonSLVFDMModel *)new_HestonSLVFDMModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(Date const &)*arg3,(HestonSLVFokkerPlanckFdmParams const &)*arg4,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_HestonSLVFDMModel__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned int jarg5, void * jarg6) {
  void * jresult ;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  Date *arg3 = 0 ;
  HestonSLVFokkerPlanckFdmParams *arg4 = 0 ;
  bool arg5 ;
  std::vector< Date > *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull1 ;
  ext::shared_ptr< HestonModel > tempnull2 ;
  HestonSLVFDMModel *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonModel > *)jarg2 : &tempnull2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (HestonSLVFokkerPlanckFdmParams *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "HestonSLVFokkerPlanckFdmParams const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  arg6 = (std::vector< Date > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (HestonSLVFDMModel *)new_HestonSLVFDMModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(Date const &)*arg3,(HestonSLVFokkerPlanckFdmParams const &)*arg4,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_HestonSLVFDMModel__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  Date *arg3 = 0 ;
  HestonSLVFokkerPlanckFdmParams *arg4 = 0 ;
  bool arg5 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull1 ;
  ext::shared_ptr< HestonModel > tempnull2 ;
  HestonSLVFDMModel *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonModel > *)jarg2 : &tempnull2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (HestonSLVFokkerPlanckFdmParams *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "HestonSLVFokkerPlanckFdmParams const & is null", 0);
    return 0;
  } 
  arg5 = jarg5 ? true : false; 
  {
    try {
      result = (HestonSLVFDMModel *)new_HestonSLVFDMModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(Date const &)*arg3,(HestonSLVFokkerPlanckFdmParams 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_HestonSLVFDMModel__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  Date *arg3 = 0 ;
  HestonSLVFokkerPlanckFdmParams *arg4 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempnull1 ;
  ext::shared_ptr< HestonModel > tempnull2 ;
  HestonSLVFDMModel *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< LocalVolTermStructure > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< HestonModel > *)jarg2 : &tempnull2; 
  arg3 = (Date *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg4 = (HestonSLVFokkerPlanckFdmParams *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "HestonSLVFokkerPlanckFdmParams const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (HestonSLVFDMModel *)new_HestonSLVFDMModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(Date const &)*arg3,(HestonSLVFokkerPlanckFdmParams 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_HestonSLVFDMModel_hestonProcess(void * jarg1) {
  void * jresult ;
  HestonSLVFDMModel *arg1 = (HestonSLVFDMModel *) 0 ;
  ext::shared_ptr< HestonProcess > result;
  
  arg1 = (HestonSLVFDMModel *)jarg1; 
  {
    try {
      result = ((HestonSLVFDMModel const *)arg1)->hestonProcess();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< HestonProcess >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HestonSLVFDMModel_localVol(void * jarg1) {
  void * jresult ;
  HestonSLVFDMModel *arg1 = (HestonSLVFDMModel *) 0 ;
  ext::shared_ptr< LocalVolTermStructure > result;
  
  arg1 = (HestonSLVFDMModel *)jarg1; 
  {
    try {
      result = ((HestonSLVFDMModel const *)arg1)->localVol();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< LocalVolTermStructure >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_HestonSLVFDMModel_leverageFunction(void * jarg1) {
  void * jresult ;
  HestonSLVFDMModel *arg1 = (HestonSLVFDMModel *) 0 ;
  ext::shared_ptr< LocalVolTermStructure > result;
  
  arg1 = (HestonSLVFDMModel *)jarg1; 
  {
    try {
      result = ((HestonSLVFDMModel const *)arg1)->leverageFunction();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< LocalVolTermStructure >(result) : 0; 
  return jresult;
}


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


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_SpreadOption(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  ext::shared_ptr< PlainVanillaPayoff > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  SpreadOption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< PlainVanillaPayoff > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  {
    try {
      result = (SpreadOption *)new SpreadOption((ext::shared_ptr< PlainVanillaPayoff > const &)*arg1,(ext::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 = result ? new ext::shared_ptr<  SpreadOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_SpreadOption(void * jarg1) {
  SpreadOption *arg1 = (SpreadOption *) 0 ;
  ext::shared_ptr< SpreadOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  SpreadOption > *)jarg1;
  arg1 = (SpreadOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KirkSpreadOptionEngine(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  ext::shared_ptr< BlackProcess > *arg1 = 0 ;
  ext::shared_ptr< BlackProcess > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< BlackProcess > tempnull1 ;
  ext::shared_ptr< BlackProcess > tempnull2 ;
  KirkSpreadOptionEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< BlackProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< BlackProcess > *)jarg2 : &tempnull2; 
  arg3 = (Handle< Quote > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (KirkSpreadOptionEngine *)new KirkSpreadOptionEngine((ext::shared_ptr< BlackProcess > const &)*arg1,(ext::shared_ptr< BlackProcess > 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 = result ? new ext::shared_ptr<  KirkSpreadOptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_KirkSpreadOptionEngine(void * jarg1) {
  KirkSpreadOptionEngine *arg1 = (KirkSpreadOptionEngine *) 0 ;
  ext::shared_ptr< KirkSpreadOptionEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  KirkSpreadOptionEngine > *)jarg1;
  arg1 = (KirkSpreadOptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); 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 & 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 & is null", 0);
    return ;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & 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 & 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 & is null", 0);
    return ;
  } 
  arg3 = (std::vector< Real > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Real > const & 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 >(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 >(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 >(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 >(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 >(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 >(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 >(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 >(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(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(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 & 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 & 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 & 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 & 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 >(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 >(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 >(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 >(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 >(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 >(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 >(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 >(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(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(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 & 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 & 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 & 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 & 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 >(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 >(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 >(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 >(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 >(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 >(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 >(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 >(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(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(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 & 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 & 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 & 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 & 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 double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructure_volatility__SWIG_0(void * jarg1, void * jarg2, double jarg3, unsigned int jarg4) {
  double jresult ;
  CapFloorTermVolatilityStructure *arg1 = (CapFloorTermVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloorTermVolatilityStructure > *)jarg1;
  arg1 = (CapFloorTermVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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 ;
  CapFloorTermVolatilityStructure *arg1 = (CapFloorTermVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloorTermVolatilityStructure > *)jarg1;
  arg1 = (CapFloorTermVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Period *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Period const & 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 ;
  CapFloorTermVolatilityStructure *arg1 = (CapFloorTermVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloorTermVolatilityStructure > *)jarg1;
  arg1 = (CapFloorTermVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 ;
  CapFloorTermVolatilityStructure *arg1 = (CapFloorTermVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloorTermVolatilityStructure > *)jarg1;
  arg1 = (CapFloorTermVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & 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 ;
  CapFloorTermVolatilityStructure *arg1 = (CapFloorTermVolatilityStructure *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  bool arg4 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloorTermVolatilityStructure > *)jarg1;
  arg1 = (CapFloorTermVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  CapFloorTermVolatilityStructure *arg1 = (CapFloorTermVolatilityStructure *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloorTermVolatilityStructure > *)jarg1;
  arg1 = (CapFloorTermVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  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_delete_CapFloorTermVolatilityStructure(void * jarg1) {
  CapFloorTermVolatilityStructure *arg1 = (CapFloorTermVolatilityStructure *) 0 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloorTermVolatilityStructure > *)jarg1;
  arg1 = (CapFloorTermVolatilityStructure *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_CapFloorTermVolatilityStructureHandle__SWIG_0(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = 0 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > tempnull1 ;
  Handle< CapFloorTermVolatilityStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (Handle< CapFloorTermVolatilityStructure > *)new Handle< CapFloorTermVolatilityStructure >((ext::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 ;
  ext::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 = result ? new ext::shared_ptr< CapFloorTermVolatilityStructure >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_currentLink(void * jarg1) {
  void * jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = result ? new ext::shared_ptr< CapFloorTermVolatilityStructure >(result) : 0; 
  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 ;
  ext::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 = result ? new ext::shared_ptr< Observable >(result) : 0; 
  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 & 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 & 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 & 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 & 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 double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_minStrike(void * jarg1) {
  double jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Real result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)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_CapFloorTermVolatilityStructureHandle_maxStrike(void * jarg1) {
  double jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Real result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)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 void * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_dayCounter(void * jarg1) {
  void * jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  SwigValueWrapper< DayCounter > result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_timeFromReference(void * jarg1, void * jarg2) {
  double jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)jarg1; 
  arg2 = (Date *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (Time)(*arg1)->timeFromReference((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_CapFloorTermVolatilityStructureHandle_calendar(void * jarg1) {
  void * jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  SwigValueWrapper< Calendar > result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_referenceDate(void * jarg1) {
  void * jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_maxDate(void * jarg1) {
  void * jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Date result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructureHandle_maxTime(void * jarg1) {
  double jresult ;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Time result;
  
  arg1 = (Handle< CapFloorTermVolatilityStructure > *)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_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 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = 0 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > tempnull1 ;
  RelinkableHandle< CapFloorTermVolatilityStructure > *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CapFloorTermVolatilityStructure > *)jarg1 : &tempnull1; 
  {
    try {
      result = (RelinkableHandle< CapFloorTermVolatilityStructure > *)new RelinkableHandle< CapFloorTermVolatilityStructure >((ext::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 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *arg2 = 0 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > tempnull2 ;
  
  arg1 = (RelinkableHandle< CapFloorTermVolatilityStructure > *)jarg1; 
  arg2 = jarg2 ? (ext::shared_ptr< CapFloorTermVolatilityStructure > *)jarg2 : &tempnull2; 
  {
    try {
      (arg1)->linkTo((ext::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_RelinkableCapFloorTermVolatilityStructureHandle_reset(void * jarg1) {
  RelinkableHandle< CapFloorTermVolatilityStructure > *arg1 = (RelinkableHandle< CapFloorTermVolatilityStructure > *) 0 ;
  
  arg1 = (RelinkableHandle< CapFloorTermVolatilityStructure > *)jarg1; 
  {
    try {
      RelinkableHandle_Sl_CapFloorTermVolatilityStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  CapFloorTermVolCurve *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Volatility > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolCurve *)new CapFloorTermVolCurve((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< Volatility > 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 = result ? new ext::shared_ptr<  CapFloorTermVolCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  CapFloorTermVolCurve *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Volatility > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolCurve *)new CapFloorTermVolCurve((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< Volatility > 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 ? new ext::shared_ptr<  CapFloorTermVolCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  CapFloorTermVolCurve *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Volatility > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  arg6 = (DayCounter *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolCurve *)new CapFloorTermVolCurve(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< Volatility > 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 = result ? new ext::shared_ptr<  CapFloorTermVolCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  CapFloorTermVolCurve *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Volatility > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Volatility > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolCurve *)new CapFloorTermVolCurve(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< Volatility > 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 ? new ext::shared_ptr<  CapFloorTermVolCurve >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CapFloorTermVolCurve(void * jarg1) {
  CapFloorTermVolCurve *arg1 = (CapFloorTermVolCurve *) 0 ;
  ext::shared_ptr< CapFloorTermVolCurve > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloorTermVolCurve > *)jarg1;
  arg1 = (CapFloorTermVolCurve *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  CapFloorTermVolSurface *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & 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 & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolSurface *)new CapFloorTermVolSurface(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CapFloorTermVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  CapFloorTermVolSurface *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & 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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolSurface *)new CapFloorTermVolSurface(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CapFloorTermVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  CapFloorTermVolSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & 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 & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolSurface *)new CapFloorTermVolSurface((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CapFloorTermVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  CapFloorTermVolSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & 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 & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolSurface *)new CapFloorTermVolSurface((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CapFloorTermVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  CapFloorTermVolSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg6 = (Matrix *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolSurface *)new CapFloorTermVolSurface((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CapFloorTermVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  CapFloorTermVolSurface *result = 0 ;
  
  arg1 = (Date *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Date const & is null", 0);
    return 0;
  } 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg6 = (Matrix *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolSurface *)new CapFloorTermVolSurface((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CapFloorTermVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  CapFloorTermVolSurface *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg6 = (Matrix *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  arg7 = (DayCounter *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolSurface *)new CapFloorTermVolSurface(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CapFloorTermVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  CapFloorTermVolSurface *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  arg4 = (std::vector< Period > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Period > const & is null", 0);
    return 0;
  } 
  arg5 = (std::vector< Rate > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg6 = (Matrix *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Matrix const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (CapFloorTermVolSurface *)new CapFloorTermVolSurface(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period > const &)*arg4,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  CapFloorTermVolSurface >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolSurface_maxDate(void * jarg1) {
  void * jresult ;
  CapFloorTermVolSurface *arg1 = (CapFloorTermVolSurface *) 0 ;
  ext::shared_ptr< CapFloorTermVolSurface const > *smartarg1 = 0 ;
  Date result;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloorTermVolSurface > *)jarg1;
  arg1 = (CapFloorTermVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((CapFloorTermVolSurface const *)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(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolSurface_minStrike(void * jarg1) {
  double jresult ;
  CapFloorTermVolSurface *arg1 = (CapFloorTermVolSurface *) 0 ;
  ext::shared_ptr< CapFloorTermVolSurface const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloorTermVolSurface > *)jarg1;
  arg1 = (CapFloorTermVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((CapFloorTermVolSurface const *)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_CapFloorTermVolSurface_maxStrike(void * jarg1) {
  double jresult ;
  CapFloorTermVolSurface *arg1 = (CapFloorTermVolSurface *) 0 ;
  ext::shared_ptr< CapFloorTermVolSurface const > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloorTermVolSurface > *)jarg1;
  arg1 = (CapFloorTermVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)((CapFloorTermVolSurface const *)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 void * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolSurface_optionTenors(void * jarg1) {
  void * jresult ;
  CapFloorTermVolSurface *arg1 = (CapFloorTermVolSurface *) 0 ;
  ext::shared_ptr< CapFloorTermVolSurface const > *smartarg1 = 0 ;
  std::vector< Period > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloorTermVolSurface > *)jarg1;
  arg1 = (CapFloorTermVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Period > *) &((CapFloorTermVolSurface const *)arg1)->optionTenors();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolSurface_optionDates(void * jarg1) {
  void * jresult ;
  CapFloorTermVolSurface *arg1 = (CapFloorTermVolSurface *) 0 ;
  ext::shared_ptr< CapFloorTermVolSurface const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloorTermVolSurface > *)jarg1;
  arg1 = (CapFloorTermVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((CapFloorTermVolSurface const *)arg1)->optionDates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolSurface_optionTimes(void * jarg1) {
  void * jresult ;
  CapFloorTermVolSurface *arg1 = (CapFloorTermVolSurface *) 0 ;
  ext::shared_ptr< CapFloorTermVolSurface const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloorTermVolSurface > *)jarg1;
  arg1 = (CapFloorTermVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((CapFloorTermVolSurface const *)arg1)->optionTimes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolSurface_strikes(void * jarg1) {
  void * jresult ;
  CapFloorTermVolSurface *arg1 = (CapFloorTermVolSurface *) 0 ;
  ext::shared_ptr< CapFloorTermVolSurface const > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const CapFloorTermVolSurface > *)jarg1;
  arg1 = (CapFloorTermVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Rate > *) &((CapFloorTermVolSurface const *)arg1)->strikes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(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) {
  CapFloorTermVolSurface *arg1 = (CapFloorTermVolSurface *) 0 ;
  ext::shared_ptr< CapFloorTermVolSurface > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  CapFloorTermVolSurface > *)jarg1;
  arg1 = (CapFloorTermVolSurface *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 ;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  Size arg2 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  StrippedOptionletBase > *)jarg1;
  arg1 = (StrippedOptionletBase *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  Size arg2 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  std::vector< Volatility > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  StrippedOptionletBase > *)jarg1;
  arg1 = (StrippedOptionletBase *)(smartarg1 ? smartarg1->get() : 0); 
  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 ;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  StrippedOptionletBase > *)jarg1;
  arg1 = (StrippedOptionletBase *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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 ;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  StrippedOptionletBase > *)jarg1;
  arg1 = (StrippedOptionletBase *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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 ;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  Size result;
  
  
  smartarg1 = (ext::shared_ptr<  StrippedOptionletBase > *)jarg1;
  arg1 = (StrippedOptionletBase *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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 ;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  StrippedOptionletBase > *)jarg1;
  arg1 = (StrippedOptionletBase *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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 ;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  SwigValueWrapper< DayCounter > result;
  
  
  smartarg1 = (ext::shared_ptr<  StrippedOptionletBase > *)jarg1;
  arg1 = (StrippedOptionletBase *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_StrippedOptionletBase_calendar(void * jarg1) {
  void * jresult ;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  SwigValueWrapper< Calendar > result;
  
  
  smartarg1 = (ext::shared_ptr<  StrippedOptionletBase > *)jarg1;
  arg1 = (StrippedOptionletBase *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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(result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_QuantLib_StrippedOptionletBase_settlementDays(void * jarg1) {
  unsigned int jresult ;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  Natural result;
  
  
  smartarg1 = (ext::shared_ptr<  StrippedOptionletBase > *)jarg1;
  arg1 = (StrippedOptionletBase *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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 ;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  BusinessDayConvention result;
  
  
  smartarg1 = (ext::shared_ptr<  StrippedOptionletBase > *)jarg1;
  arg1 = (StrippedOptionletBase *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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 int SWIGSTDCALL CSharp_QuantLib_StrippedOptionletBase_volatilityType(void * jarg1) {
  int jresult ;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  VolatilityType result;
  
  
  smartarg1 = (ext::shared_ptr<  StrippedOptionletBase > *)jarg1;
  arg1 = (StrippedOptionletBase *)(smartarg1 ? smartarg1->get() : 0); 
  {
    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 double SWIGSTDCALL CSharp_QuantLib_StrippedOptionletBase_displacement(void * jarg1) {
  double jresult ;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  StrippedOptionletBase > *)jarg1;
  arg1 = (StrippedOptionletBase *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)(arg1)->displacement();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_StrippedOptionletBase(void * jarg1) {
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  StrippedOptionletBase > *)jarg1;
  arg1 = (StrippedOptionletBase *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_StrippedOptionlet__SWIG_0(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9, double jarg10) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  ext::shared_ptr< IborIndex > arg4 ;
  std::vector< Date > *arg5 = 0 ;
  std::vector< Rate > *arg6 = 0 ;
  std::vector< std::vector< Handle< Quote > > > arg7 ;
  SwigValueWrapper< DayCounter > arg8 ;
  VolatilityType arg9 ;
  Real arg10 ;
  std::vector< std::vector< Handle< Quote > > > *argp7 ;
  DayCounter *argp8 ;
  StrippedOptionlet *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  if (jarg4) arg4 = *(ext::shared_ptr< IborIndex > *)jarg4; 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Rate > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  argp7 = (std::vector< std::vector< Handle< Quote > > > *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< std::vector< Handle< Quote > > >", 0);
    return 0;
  }
  arg7 = *argp7; 
  argp8 = (DayCounter *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg8 = *argp8; 
  arg9 = (VolatilityType)jarg9; 
  arg10 = (Real)jarg10; 
  {
    try {
      result = (StrippedOptionlet *)new StrippedOptionlet(arg1,(Calendar const &)*arg2,arg3,arg4,(std::vector< Date > const &)*arg5,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  StrippedOptionlet >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_StrippedOptionlet__SWIG_1(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8, int jarg9) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  ext::shared_ptr< IborIndex > arg4 ;
  std::vector< Date > *arg5 = 0 ;
  std::vector< Rate > *arg6 = 0 ;
  std::vector< std::vector< Handle< Quote > > > arg7 ;
  SwigValueWrapper< DayCounter > arg8 ;
  VolatilityType arg9 ;
  std::vector< std::vector< Handle< Quote > > > *argp7 ;
  DayCounter *argp8 ;
  StrippedOptionlet *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  if (jarg4) arg4 = *(ext::shared_ptr< IborIndex > *)jarg4; 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Rate > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  argp7 = (std::vector< std::vector< Handle< Quote > > > *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< std::vector< Handle< Quote > > >", 0);
    return 0;
  }
  arg7 = *argp7; 
  argp8 = (DayCounter *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg8 = *argp8; 
  arg9 = (VolatilityType)jarg9; 
  {
    try {
      result = (StrippedOptionlet *)new StrippedOptionlet(arg1,(Calendar const &)*arg2,arg3,arg4,(std::vector< Date > const &)*arg5,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  StrippedOptionlet >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_StrippedOptionlet__SWIG_2(unsigned int jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  ext::shared_ptr< IborIndex > arg4 ;
  std::vector< Date > *arg5 = 0 ;
  std::vector< Rate > *arg6 = 0 ;
  std::vector< std::vector< Handle< Quote > > > arg7 ;
  SwigValueWrapper< DayCounter > arg8 ;
  std::vector< std::vector< Handle< Quote > > > *argp7 ;
  DayCounter *argp8 ;
  StrippedOptionlet *result = 0 ;
  
  arg1 = (Natural)jarg1; 
  arg2 = (Calendar *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg3 = (BusinessDayConvention)jarg3; 
  if (jarg4) arg4 = *(ext::shared_ptr< IborIndex > *)jarg4; 
  arg5 = (std::vector< Date > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg6 = (std::vector< Rate > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  argp7 = (std::vector< std::vector< Handle< Quote > > > *)jarg7; 
  if (!argp7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< std::vector< Handle< Quote > > >", 0);
    return 0;
  }
  arg7 = *argp7; 
  argp8 = (DayCounter *)jarg8; 
  if (!argp8) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null DayCounter", 0);
    return 0;
  }
  arg8 = *argp8; 
  {
    try {
      result = (StrippedOptionlet *)new StrippedOptionlet(arg1,(Calendar const &)*arg2,arg3,arg4,(std::vector< Date > const &)*arg5,(std::vector< Rate > 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 ? new ext::shared_ptr<  StrippedOptionlet >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_StrippedOptionlet(void * jarg1) {
  StrippedOptionlet *arg1 = (StrippedOptionlet *) 0 ;
  ext::shared_ptr< StrippedOptionlet > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  StrippedOptionlet > *)jarg1;
  arg1 = (StrippedOptionlet *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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 ;
  ext::shared_ptr< CapFloorTermVolSurface > *arg1 = 0 ;
  ext::shared_ptr< IborIndex > *arg2 = 0 ;
  Rate arg3 ;
  Real arg4 ;
  Natural arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  bool arg9 ;
  ext::shared_ptr< CapFloorTermVolSurface > tempnull1 ;
  ext::shared_ptr< IborIndex > tempnull2 ;
  OptionletStripper1 *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CapFloorTermVolSurface > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< IborIndex > *)jarg2 : &tempnull2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Natural)jarg5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  arg8 = (Real)jarg8; 
  arg9 = jarg9 ? true : false; 
  {
    try {
      result = (OptionletStripper1 *)new OptionletStripper1((ext::shared_ptr< CapFloorTermVolSurface > const &)*arg1,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  OptionletStripper1 >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< CapFloorTermVolSurface > *arg1 = 0 ;
  ext::shared_ptr< IborIndex > *arg2 = 0 ;
  Rate arg3 ;
  Real arg4 ;
  Natural arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  ext::shared_ptr< CapFloorTermVolSurface > tempnull1 ;
  ext::shared_ptr< IborIndex > tempnull2 ;
  OptionletStripper1 *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CapFloorTermVolSurface > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< IborIndex > *)jarg2 : &tempnull2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Natural)jarg5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  arg8 = (Real)jarg8; 
  {
    try {
      result = (OptionletStripper1 *)new OptionletStripper1((ext::shared_ptr< CapFloorTermVolSurface > const &)*arg1,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  OptionletStripper1 >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< CapFloorTermVolSurface > *arg1 = 0 ;
  ext::shared_ptr< IborIndex > *arg2 = 0 ;
  Rate arg3 ;
  Real arg4 ;
  Natural arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  VolatilityType arg7 ;
  ext::shared_ptr< CapFloorTermVolSurface > tempnull1 ;
  ext::shared_ptr< IborIndex > tempnull2 ;
  OptionletStripper1 *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CapFloorTermVolSurface > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< IborIndex > *)jarg2 : &tempnull2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Natural)jarg5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg7 = (VolatilityType)jarg7; 
  {
    try {
      result = (OptionletStripper1 *)new OptionletStripper1((ext::shared_ptr< CapFloorTermVolSurface > const &)*arg1,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  OptionletStripper1 >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  ext::shared_ptr< CapFloorTermVolSurface > *arg1 = 0 ;
  ext::shared_ptr< IborIndex > *arg2 = 0 ;
  Rate arg3 ;
  Real arg4 ;
  Natural arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  ext::shared_ptr< CapFloorTermVolSurface > tempnull1 ;
  ext::shared_ptr< IborIndex > tempnull2 ;
  OptionletStripper1 *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CapFloorTermVolSurface > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< IborIndex > *)jarg2 : &tempnull2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Natural)jarg5; 
  arg6 = (Handle< YieldTermStructure > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (OptionletStripper1 *)new OptionletStripper1((ext::shared_ptr< CapFloorTermVolSurface > const &)*arg1,(ext::shared_ptr< IborIndex > 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 = result ? new ext::shared_ptr<  OptionletStripper1 >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionletStripper1__SWIG_4(void * jarg1, void * jarg2, double jarg3, double jarg4, unsigned int jarg5) {
  void * jresult ;
  ext::shared_ptr< CapFloorTermVolSurface > *arg1 = 0 ;
  ext::shared_ptr< IborIndex > *arg2 = 0 ;
  Rate arg3 ;
  Real arg4 ;
  Natural arg5 ;
  ext::shared_ptr< CapFloorTermVolSurface > tempnull1 ;
  ext::shared_ptr< IborIndex > tempnull2 ;
  OptionletStripper1 *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CapFloorTermVolSurface > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< IborIndex > *)jarg2 : &tempnull2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Real)jarg4; 
  arg5 = (Natural)jarg5; 
  {
    try {
      result = (OptionletStripper1 *)new OptionletStripper1((ext::shared_ptr< CapFloorTermVolSurface > const &)*arg1,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  OptionletStripper1 >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionletStripper1__SWIG_5(void * jarg1, void * jarg2, double jarg3, double jarg4) {
  void * jresult ;
  ext::shared_ptr< CapFloorTermVolSurface > *arg1 = 0 ;
  ext::shared_ptr< IborIndex > *arg2 = 0 ;
  Rate arg3 ;
  Real arg4 ;
  ext::shared_ptr< CapFloorTermVolSurface > tempnull1 ;
  ext::shared_ptr< IborIndex > tempnull2 ;
  OptionletStripper1 *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CapFloorTermVolSurface > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< IborIndex > *)jarg2 : &tempnull2; 
  arg3 = (Rate)jarg3; 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (OptionletStripper1 *)new OptionletStripper1((ext::shared_ptr< CapFloorTermVolSurface > const &)*arg1,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  OptionletStripper1 >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionletStripper1__SWIG_6(void * jarg1, void * jarg2, double jarg3) {
  void * jresult ;
  ext::shared_ptr< CapFloorTermVolSurface > *arg1 = 0 ;
  ext::shared_ptr< IborIndex > *arg2 = 0 ;
  Rate arg3 ;
  ext::shared_ptr< CapFloorTermVolSurface > tempnull1 ;
  ext::shared_ptr< IborIndex > tempnull2 ;
  OptionletStripper1 *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CapFloorTermVolSurface > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< IborIndex > *)jarg2 : &tempnull2; 
  arg3 = (Rate)jarg3; 
  {
    try {
      result = (OptionletStripper1 *)new OptionletStripper1((ext::shared_ptr< CapFloorTermVolSurface > const &)*arg1,(ext::shared_ptr< IborIndex > 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 ? new ext::shared_ptr<  OptionletStripper1 >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_OptionletStripper1__SWIG_7(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< CapFloorTermVolSurface > *arg1 = 0 ;
  ext::shared_ptr< IborIndex > *arg2 = 0 ;
  ext::shared_ptr< CapFloorTermVolSurface > tempnull1 ;
  ext::shared_ptr< IborIndex > tempnull2 ;
  OptionletStripper1 *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< CapFloorTermVolSurface > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< IborIndex > *)jarg2 : &tempnull2; 
  {
    try {
      result = (OptionletStripper1 *)new OptionletStripper1((ext::shared_ptr< CapFloorTermVolSurface > const &)*arg1,(ext::shared_ptr< IborIndex > const &)*arg2);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  OptionletStripper1 >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_OptionletStripper1_capFloorPrices(void * jarg1) {
  void * jresult ;
  OptionletStripper1 *arg1 = (OptionletStripper1 *) 0 ;
  ext::shared_ptr< OptionletStripper1 const > *smartarg1 = 0 ;
  Matrix *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const OptionletStripper1 > *)jarg1;
  arg1 = (OptionletStripper1 *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Matrix *) &((OptionletStripper1 const *)arg1)->capFloorPrices();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  OptionletStripper1 *arg1 = (OptionletStripper1 *) 0 ;
  ext::shared_ptr< OptionletStripper1 const > *smartarg1 = 0 ;
  Matrix *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const OptionletStripper1 > *)jarg1;
  arg1 = (OptionletStripper1 *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Matrix *) &((OptionletStripper1 const *)arg1)->capFloorVolatilities();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  OptionletStripper1 *arg1 = (OptionletStripper1 *) 0 ;
  ext::shared_ptr< OptionletStripper1 const > *smartarg1 = 0 ;
  Matrix *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const OptionletStripper1 > *)jarg1;
  arg1 = (OptionletStripper1 *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Matrix *) &((OptionletStripper1 const *)arg1)->optionletPrices();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(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 ;
  OptionletStripper1 *arg1 = (OptionletStripper1 *) 0 ;
  ext::shared_ptr< OptionletStripper1 const > *smartarg1 = 0 ;
  Rate result;
  
  
  smartarg1 = (ext::shared_ptr< const OptionletStripper1 > *)jarg1;
  arg1 = (OptionletStripper1 *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Rate)((OptionletStripper1 const *)arg1)->switchStrike();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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) {
  OptionletStripper1 *arg1 = (OptionletStripper1 *) 0 ;
  ext::shared_ptr< OptionletStripper1 > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  OptionletStripper1 > *)jarg1;
  arg1 = (OptionletStripper1 *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  ext::shared_ptr< StrippedOptionletBase > *arg1 = 0 ;
  ext::shared_ptr< StrippedOptionletBase > tempnull1 ;
  StrippedOptionletAdapter *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< StrippedOptionletBase > *)jarg1 : &tempnull1; 
  {
    try {
      result = (StrippedOptionletAdapter *)new StrippedOptionletAdapter((ext::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 = result ? new ext::shared_ptr<  StrippedOptionletAdapter >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_StrippedOptionletAdapter(void * jarg1) {
  StrippedOptionletAdapter *arg1 = (StrippedOptionletAdapter *) 0 ;
  ext::shared_ptr< StrippedOptionletAdapter > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  StrippedOptionletAdapter > *)jarg1;
  arg1 = (StrippedOptionletAdapter *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, int jarg4) {
  void * jresult ;
  ext::shared_ptr< VanillaSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  Settlement::Type arg3 ;
  Settlement::Method arg4 ;
  ext::shared_ptr< VanillaSwap > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  Swaption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< VanillaSwap > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  arg3 = (Settlement::Type)jarg3; 
  arg4 = (Settlement::Method)jarg4; 
  {
    try {
      result = (Swaption *)new Swaption((ext::shared_ptr< VanillaSwap > const &)*arg1,(ext::shared_ptr< Exercise > 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 ? new ext::shared_ptr<  Swaption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Swaption__SWIG_1(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< VanillaSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  Settlement::Type arg3 ;
  ext::shared_ptr< VanillaSwap > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  Swaption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< VanillaSwap > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  arg3 = (Settlement::Type)jarg3; 
  {
    try {
      result = (Swaption *)new Swaption((ext::shared_ptr< VanillaSwap > const &)*arg1,(ext::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 = result ? new ext::shared_ptr<  Swaption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_Swaption__SWIG_2(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< VanillaSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  ext::shared_ptr< VanillaSwap > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  Swaption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< VanillaSwap > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  {
    try {
      result = (Swaption *)new Swaption((ext::shared_ptr< VanillaSwap > const &)*arg1,(ext::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 = result ? new ext::shared_ptr<  Swaption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_QuantLib_Swaption_settlementType(void * jarg1) {
  int jresult ;
  Swaption *arg1 = (Swaption *) 0 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  Settlement::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const Swaption > *)jarg1;
  arg1 = (Swaption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Settlement::Type)((Swaption const *)arg1)->settlementType();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_Swaption_settlementMethod(void * jarg1) {
  int jresult ;
  Swaption *arg1 = (Swaption *) 0 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  Settlement::Method result;
  
  
  smartarg1 = (ext::shared_ptr< const Swaption > *)jarg1;
  arg1 = (Swaption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Settlement::Method)((Swaption const *)arg1)->settlementMethod();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (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_Swaption_type(void * jarg1) {
  int jresult ;
  Swaption *arg1 = (Swaption *) 0 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  VanillaSwap::Type result;
  
  
  smartarg1 = (ext::shared_ptr< const Swaption > *)jarg1;
  arg1 = (Swaption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (VanillaSwap::Type)((Swaption 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_Swaption_underlyingSwap(void * jarg1) {
  void * jresult ;
  Swaption *arg1 = (Swaption *) 0 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  ext::shared_ptr< VanillaSwap > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const Swaption > *)jarg1;
  arg1 = (Swaption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (ext::shared_ptr< VanillaSwap > *) &((Swaption const *)arg1)->underlyingSwap();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = *result ? new ext::shared_ptr< VanillaSwap >(*result) : 0; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_Swaption_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 ;
  Swaption *arg1 = (Swaption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  VolatilityType arg9 ;
  Real arg10 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const Swaption > *)jarg1;
  arg1 = (Swaption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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)((Swaption const *)arg1)->impliedVolatility(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_Swaption_impliedVolatility__SWIG_1(void * jarg1, double jarg2, void * jarg3, double jarg4, double jarg5, unsigned int jarg6, double jarg7, double jarg8, int jarg9) {
  double jresult ;
  Swaption *arg1 = (Swaption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  VolatilityType arg9 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const Swaption > *)jarg1;
  arg1 = (Swaption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & 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)((Swaption const *)arg1)->impliedVolatility(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_Swaption_impliedVolatility__SWIG_2(void * jarg1, double jarg2, void * jarg3, double jarg4, double jarg5, unsigned int jarg6, double jarg7, double jarg8) {
  double jresult ;
  Swaption *arg1 = (Swaption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const Swaption > *)jarg1;
  arg1 = (Swaption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Natural)jarg6; 
  arg7 = (Volatility)jarg7; 
  arg8 = (Volatility)jarg8; 
  {
    try {
      result = (Volatility)((Swaption const *)arg1)->impliedVolatility(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_Swaption_impliedVolatility__SWIG_3(void * jarg1, double jarg2, void * jarg3, double jarg4, double jarg5, unsigned int jarg6, double jarg7) {
  double jresult ;
  Swaption *arg1 = (Swaption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const Swaption > *)jarg1;
  arg1 = (Swaption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Natural)jarg6; 
  arg7 = (Volatility)jarg7; 
  {
    try {
      result = (Volatility)((Swaption const *)arg1)->impliedVolatility(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_Swaption_impliedVolatility__SWIG_4(void * jarg1, double jarg2, void * jarg3, double jarg4, double jarg5, unsigned int jarg6) {
  double jresult ;
  Swaption *arg1 = (Swaption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const Swaption > *)jarg1;
  arg1 = (Swaption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  arg6 = (Natural)jarg6; 
  {
    try {
      result = (Volatility)((Swaption const *)arg1)->impliedVolatility(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_Swaption_impliedVolatility__SWIG_5(void * jarg1, double jarg2, void * jarg3, double jarg4, double jarg5) {
  double jresult ;
  Swaption *arg1 = (Swaption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const Swaption > *)jarg1;
  arg1 = (Swaption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  arg5 = (Real)jarg5; 
  {
    try {
      result = (Volatility)((Swaption const *)arg1)->impliedVolatility(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_Swaption_impliedVolatility__SWIG_6(void * jarg1, double jarg2, void * jarg3, double jarg4) {
  double jresult ;
  Swaption *arg1 = (Swaption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  Volatility result;
  
  
  smartarg1 = (ext::shared_ptr< const Swaption > *)jarg1;
  arg1 = (Swaption *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (Real)jarg2; 
  arg3 = (Handle< YieldTermStructure > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg4 = (Volatility)jarg4; 
  {
    try {
      result = (Volatility)((Swaption const *)arg1)->impliedVolatility(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 double SWIGSTDCALL CSharp_QuantLib_Swaption_vega(void * jarg1) {
  double jresult ;
  Swaption *arg1 = (Swaption *) 0 ;
  ext::shared_ptr< Swaption > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Swaption > *)jarg1;
  arg1 = (Swaption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)Swaption_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_Swaption_delta(void * jarg1) {
  double jresult ;
  Swaption *arg1 = (Swaption *) 0 ;
  ext::shared_ptr< Swaption > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Swaption > *)jarg1;
  arg1 = (Swaption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)Swaption_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_Swaption_annuity(void * jarg1) {
  double jresult ;
  Swaption *arg1 = (Swaption *) 0 ;
  ext::shared_ptr< Swaption > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  Swaption > *)jarg1;
  arg1 = (Swaption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)Swaption_annuity(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_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_Swaption(void * jarg1) {
  Swaption *arg1 = (Swaption *) 0 ;
  ext::shared_ptr< Swaption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  Swaption > *)jarg1;
  arg1 = (Swaption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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, int jarg4) {
  void * jresult ;
  ext::shared_ptr< NonstandardSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  Settlement::Type arg3 ;
  Settlement::Method arg4 ;
  ext::shared_ptr< NonstandardSwap > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  NonstandardSwaption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< NonstandardSwap > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  arg3 = (Settlement::Type)jarg3; 
  arg4 = (Settlement::Method)jarg4; 
  {
    try {
      result = (NonstandardSwaption *)new NonstandardSwaption((ext::shared_ptr< NonstandardSwap > const &)*arg1,(ext::shared_ptr< Exercise > 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 ? new ext::shared_ptr<  NonstandardSwaption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NonstandardSwaption__SWIG_1(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< NonstandardSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  Settlement::Type arg3 ;
  ext::shared_ptr< NonstandardSwap > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  NonstandardSwaption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< NonstandardSwap > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  arg3 = (Settlement::Type)jarg3; 
  {
    try {
      result = (NonstandardSwaption *)new NonstandardSwaption((ext::shared_ptr< NonstandardSwap > const &)*arg1,(ext::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 = result ? new ext::shared_ptr<  NonstandardSwaption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NonstandardSwaption__SWIG_2(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< NonstandardSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  ext::shared_ptr< NonstandardSwap > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  NonstandardSwaption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< NonstandardSwap > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  {
    try {
      result = (NonstandardSwaption *)new NonstandardSwaption((ext::shared_ptr< NonstandardSwap > const &)*arg1,(ext::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 = result ? new ext::shared_ptr<  NonstandardSwaption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NonstandardSwaption_underlyingSwap(void * jarg1) {
  void * jresult ;
  NonstandardSwaption *arg1 = (NonstandardSwaption *) 0 ;
  ext::shared_ptr< NonstandardSwaption const > *smartarg1 = 0 ;
  ext::shared_ptr< NonstandardSwap > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const NonstandardSwaption > *)jarg1;
  arg1 = (NonstandardSwaption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (ext::shared_ptr< NonstandardSwap > *) &((NonstandardSwaption const *)arg1)->underlyingSwap();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = *result ? new ext::shared_ptr< NonstandardSwap >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NonstandardSwaption_calibrationBasket(void * jarg1, void * jarg2, void * jarg3, const char * jarg4) {
  void * jresult ;
  NonstandardSwaption *arg1 = (NonstandardSwaption *) 0 ;
  ext::shared_ptr< SwapIndex > arg2 ;
  ext::shared_ptr< SwaptionVolatilityStructure > arg3 ;
  std::string arg4 ;
  ext::shared_ptr< NonstandardSwaption > *smartarg1 = 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > result;
  
  
  smartarg1 = (ext::shared_ptr<  NonstandardSwaption > *)jarg1;
  arg1 = (NonstandardSwaption *)(smartarg1 ? smartarg1->get() : 0); 
  if (jarg2) arg2 = *(ext::shared_ptr< SwapIndex > *)jarg2; 
  if (jarg3) arg3 = *(ext::shared_ptr< SwaptionVolatilityStructure > *)jarg3; 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg4)->assign(jarg4); 
  {
    try {
      result = NonstandardSwaption_calibrationBasket(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(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< ext::shared_ptr< BlackCalibrationHelper > >(result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NonstandardSwaption_probabilities(void * jarg1) {
  void * jresult ;
  NonstandardSwaption *arg1 = (NonstandardSwaption *) 0 ;
  ext::shared_ptr< NonstandardSwaption > *smartarg1 = 0 ;
  std::vector< Real > result;
  
  
  smartarg1 = (ext::shared_ptr<  NonstandardSwaption > *)jarg1;
  arg1 = (NonstandardSwaption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = NonstandardSwaption_probabilities(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NonstandardSwaption(void * jarg1) {
  NonstandardSwaption *arg1 = (NonstandardSwaption *) 0 ;
  ext::shared_ptr< NonstandardSwaption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  NonstandardSwaption > *)jarg1;
  arg1 = (NonstandardSwaption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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__SWIG_0(void * jarg1, void * jarg2, int jarg3, int jarg4) {
  void * jresult ;
  ext::shared_ptr< FloatFloatSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  Settlement::Type arg3 ;
  Settlement::Method arg4 ;
  ext::shared_ptr< FloatFloatSwap > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  FloatFloatSwaption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FloatFloatSwap > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  arg3 = (Settlement::Type)jarg3; 
  arg4 = (Settlement::Method)jarg4; 
  {
    try {
      result = (FloatFloatSwaption *)new FloatFloatSwaption((ext::shared_ptr< FloatFloatSwap > const &)*arg1,(ext::shared_ptr< Exercise > 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 ? new ext::shared_ptr<  FloatFloatSwaption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatFloatSwaption__SWIG_1(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  ext::shared_ptr< FloatFloatSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  Settlement::Type arg3 ;
  ext::shared_ptr< FloatFloatSwap > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  FloatFloatSwaption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FloatFloatSwap > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  arg3 = (Settlement::Type)jarg3; 
  {
    try {
      result = (FloatFloatSwaption *)new FloatFloatSwaption((ext::shared_ptr< FloatFloatSwap > const &)*arg1,(ext::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 = result ? new ext::shared_ptr<  FloatFloatSwaption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FloatFloatSwaption__SWIG_2(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< FloatFloatSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  ext::shared_ptr< FloatFloatSwap > tempnull1 ;
  ext::shared_ptr< Exercise > tempnull2 ;
  FloatFloatSwaption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< FloatFloatSwap > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< Exercise > *)jarg2 : &tempnull2; 
  {
    try {
      result = (FloatFloatSwaption *)new FloatFloatSwaption((ext::shared_ptr< FloatFloatSwap > const &)*arg1,(ext::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 = result ? new ext::shared_ptr<  FloatFloatSwaption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FloatFloatSwaption_underlyingSwap(void * jarg1) {
  void * jresult ;
  FloatFloatSwaption *arg1 = (FloatFloatSwaption *) 0 ;
  ext::shared_ptr< FloatFloatSwaption > *smartarg1 = 0 ;
  ext::shared_ptr< FloatFloatSwap > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FloatFloatSwaption > *)jarg1;
  arg1 = (FloatFloatSwaption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (ext::shared_ptr< FloatFloatSwap > *) &(arg1)->underlyingSwap();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = *result ? new ext::shared_ptr< FloatFloatSwap >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_FloatFloatSwaption_calibrationBasket(void * jarg1, void * jarg2, void * jarg3, const char * jarg4) {
  void * jresult ;
  FloatFloatSwaption *arg1 = (FloatFloatSwaption *) 0 ;
  ext::shared_ptr< SwapIndex > arg2 ;
  ext::shared_ptr< SwaptionVolatilityStructure > arg3 ;
  std::string arg4 ;
  ext::shared_ptr< FloatFloatSwaption > *smartarg1 = 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > result;
  
  
  smartarg1 = (ext::shared_ptr<  FloatFloatSwaption > *)jarg1;
  arg1 = (FloatFloatSwaption *)(smartarg1 ? smartarg1->get() : 0); 
  if (jarg2) arg2 = *(ext::shared_ptr< SwapIndex > *)jarg2; 
  if (jarg3) arg3 = *(ext::shared_ptr< SwaptionVolatilityStructure > *)jarg3; 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg4)->assign(jarg4); 
  {
    try {
      result = FloatFloatSwaption_calibrationBasket(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(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< ext::shared_ptr< BlackCalibrationHelper > >(result); 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_QuantLib_FloatFloatSwaption_underlyingValue(void * jarg1) {
  double jresult ;
  FloatFloatSwaption *arg1 = (FloatFloatSwaption *) 0 ;
  ext::shared_ptr< FloatFloatSwaption > *smartarg1 = 0 ;
  Real result;
  
  
  smartarg1 = (ext::shared_ptr<  FloatFloatSwaption > *)jarg1;
  arg1 = (FloatFloatSwaption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (Real)FloatFloatSwaption_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_FloatFloatSwaption_probabilities(void * jarg1) {
  void * jresult ;
  FloatFloatSwaption *arg1 = (FloatFloatSwaption *) 0 ;
  ext::shared_ptr< FloatFloatSwaption > *smartarg1 = 0 ;
  std::vector< Real > result;
  
  
  smartarg1 = (ext::shared_ptr<  FloatFloatSwaption > *)jarg1;
  arg1 = (FloatFloatSwaption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = FloatFloatSwaption_probabilities(arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FloatFloatSwaption(void * jarg1) {
  FloatFloatSwaption *arg1 = (FloatFloatSwaption *) 0 ;
  ext::shared_ptr< FloatFloatSwaption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FloatFloatSwaption > *)jarg1;
  arg1 = (FloatFloatSwaption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  BlackSwaptionEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Real)jarg4; 
  {
    try {
      result = (BlackSwaptionEngine *)new BlackSwaptionEngine((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 = result ? new ext::shared_ptr<  BlackSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  BlackSwaptionEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackSwaptionEngine *)new BlackSwaptionEngine((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 = result ? new ext::shared_ptr<  BlackSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  BlackSwaptionEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackSwaptionEngine *)new BlackSwaptionEngine((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 = result ? new ext::shared_ptr<  BlackSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  BlackSwaptionEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< SwaptionVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BlackSwaptionEngine *)new BlackSwaptionEngine((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 = result ? new ext::shared_ptr<  BlackSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BlackSwaptionEngine(void * jarg1) {
  BlackSwaptionEngine *arg1 = (BlackSwaptionEngine *) 0 ;
  ext::shared_ptr< BlackSwaptionEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BlackSwaptionEngine > *)jarg1;
  arg1 = (BlackSwaptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  BachelierSwaptionEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BachelierSwaptionEngine *)new BachelierSwaptionEngine((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 = result ? new ext::shared_ptr<  BachelierSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  BachelierSwaptionEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< Quote > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< Quote > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BachelierSwaptionEngine *)new BachelierSwaptionEngine((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 = result ? new ext::shared_ptr<  BachelierSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  BachelierSwaptionEngine *result = 0 ;
  
  arg1 = (Handle< YieldTermStructure > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< YieldTermStructure > const & is null", 0);
    return 0;
  } 
  arg2 = (Handle< SwaptionVolatilityStructure > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Handle< SwaptionVolatilityStructure > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (BachelierSwaptionEngine *)new BachelierSwaptionEngine((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 = result ? new ext::shared_ptr<  BachelierSwaptionEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_BachelierSwaptionEngine(void * jarg1) {
  BachelierSwaptionEngine *arg1 = (BachelierSwaptionEngine *) 0 ;
  ext::shared_ptr< BachelierSwaptionEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  BachelierSwaptionEngine > *)jarg1;
  arg1 = (BachelierSwaptionEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_VanillaSwingOption(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< Payoff > *arg1 = 0 ;
  ext::shared_ptr< SwingExercise > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< Payoff > tempnull1 ;
  ext::shared_ptr< SwingExercise > tempnull2 ;
  VanillaSwingOption *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< Payoff > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< SwingExercise > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (VanillaSwingOption *)new VanillaSwingOption((ext::shared_ptr< Payoff > const &)*arg1,(ext::shared_ptr< SwingExercise > 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 ? new ext::shared_ptr<  VanillaSwingOption >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_VanillaSwingOption(void * jarg1) {
  VanillaSwingOption *arg1 = (VanillaSwingOption *) 0 ;
  ext::shared_ptr< VanillaSwingOption > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  VanillaSwingOption > *)jarg1;
  arg1 = (VanillaSwingOption *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSimpleBSSwingEngine__SWIG_0(void * jarg1, unsigned long jarg2, unsigned long jarg3, void * jarg4) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  FdmSchemeDesc *arg4 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdSimpleBSSwingEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  arg4 = (FdmSchemeDesc *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdSimpleBSSwingEngine *)new FdSimpleBSSwingEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,(FdmSchemeDesc 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 ? new ext::shared_ptr<  FdSimpleBSSwingEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSimpleBSSwingEngine__SWIG_1(void * jarg1, unsigned long jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdSimpleBSSwingEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdSimpleBSSwingEngine *)new FdSimpleBSSwingEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdSimpleBSSwingEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSimpleBSSwingEngine__SWIG_2(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdSimpleBSSwingEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  arg2 = (Size)jarg2; 
  {
    try {
      result = (FdSimpleBSSwingEngine *)new FdSimpleBSSwingEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > 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 ? new ext::shared_ptr<  FdSimpleBSSwingEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSimpleBSSwingEngine__SWIG_3(void * jarg1) {
  void * jresult ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempnull1 ;
  FdSimpleBSSwingEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< GeneralizedBlackScholesProcess > *)jarg1 : &tempnull1; 
  {
    try {
      result = (FdSimpleBSSwingEngine *)new FdSimpleBSSwingEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdSimpleBSSwingEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdSimpleBSSwingEngine(void * jarg1) {
  FdSimpleBSSwingEngine *arg1 = (FdSimpleBSSwingEngine *) 0 ;
  ext::shared_ptr< FdSimpleBSSwingEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdSimpleBSSwingEngine > *)jarg1;
  arg1 = (FdSimpleBSSwingEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSimpleExtOUJumpSwingEngine__SWIG_0(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  ext::shared_ptr< ExtOUWithJumpsProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  std::vector< std::pair< Time,Real > > *arg6 = 0 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  FdSimpleExtOUJumpSwingEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ExtOUWithJumpsProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (std::vector< std::pair< Time,Real > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< Time,Real > > const & is null", 0);
    return 0;
  } 
  arg7 = (FdmSchemeDesc *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "FdmSchemeDesc const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdSimpleExtOUJumpSwingEngine *)new_FdSimpleExtOUJumpSwingEngine__SWIG_0((ext::shared_ptr< ExtOUWithJumpsProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),(std::vector< std::pair< double,double > > const &)*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 = result ? new ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSimpleExtOUJumpSwingEngine__SWIG_1(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, void * jarg6) {
  void * jresult ;
  ext::shared_ptr< ExtOUWithJumpsProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  std::vector< std::pair< Time,Real > > *arg6 = 0 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  FdSimpleExtOUJumpSwingEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ExtOUWithJumpsProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  arg6 = (std::vector< std::pair< Time,Real > > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< Time,Real > > const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (FdSimpleExtOUJumpSwingEngine *)new_FdSimpleExtOUJumpSwingEngine__SWIG_0((ext::shared_ptr< ExtOUWithJumpsProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),(std::vector< std::pair< double,double > > 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 ? new ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSimpleExtOUJumpSwingEngine__SWIG_2(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5) {
  void * jresult ;
  ext::shared_ptr< ExtOUWithJumpsProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  FdSimpleExtOUJumpSwingEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ExtOUWithJumpsProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  arg5 = (Size)jarg5; 
  {
    try {
      result = (FdSimpleExtOUJumpSwingEngine *)new_FdSimpleExtOUJumpSwingEngine__SWIG_0((ext::shared_ptr< ExtOUWithJumpsProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSimpleExtOUJumpSwingEngine__SWIG_3(void * jarg1, void * jarg2, unsigned long jarg3, unsigned long jarg4) {
  void * jresult ;
  ext::shared_ptr< ExtOUWithJumpsProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  FdSimpleExtOUJumpSwingEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ExtOUWithJumpsProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  arg4 = (Size)jarg4; 
  {
    try {
      result = (FdSimpleExtOUJumpSwingEngine *)new_FdSimpleExtOUJumpSwingEngine__SWIG_0((ext::shared_ptr< ExtOUWithJumpsProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(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 ? new ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSimpleExtOUJumpSwingEngine__SWIG_4(void * jarg1, void * jarg2, unsigned long jarg3) {
  void * jresult ;
  ext::shared_ptr< ExtOUWithJumpsProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  FdSimpleExtOUJumpSwingEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ExtOUWithJumpsProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  arg3 = (Size)jarg3; 
  {
    try {
      result = (FdSimpleExtOUJumpSwingEngine *)new_FdSimpleExtOUJumpSwingEngine__SWIG_0((ext::shared_ptr< ExtOUWithJumpsProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  
  jresult = result ? new ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_FdSimpleExtOUJumpSwingEngine__SWIG_5(void * jarg1, void * jarg2) {
  void * jresult ;
  ext::shared_ptr< ExtOUWithJumpsProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > tempnull1 ;
  ext::shared_ptr< YieldTermStructure > tempnull2 ;
  FdSimpleExtOUJumpSwingEngine *result = 0 ;
  
  arg1 = jarg1 ? (ext::shared_ptr< ExtOUWithJumpsProcess > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (ext::shared_ptr< YieldTermStructure > *)jarg2 : &tempnull2; 
  {
    try {
      result = (FdSimpleExtOUJumpSwingEngine *)new_FdSimpleExtOUJumpSwingEngine__SWIG_0((ext::shared_ptr< ExtOUWithJumpsProcess > const &)*arg1,(ext::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 ? new ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_FdSimpleExtOUJumpSwingEngine(void * jarg1) {
  FdSimpleExtOUJumpSwingEngine *arg1 = (FdSimpleExtOUJumpSwingEngine *) 0 ;
  ext::shared_ptr< FdSimpleExtOUJumpSwingEngine > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine > *)jarg1;
  arg1 = (FdSimpleExtOUJumpSwingEngine *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& 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 & 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 >(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 & 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 >(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 & 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 >(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 & 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 >(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 & 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 >(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 & 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 >(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 & 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 >(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 ;
  InterpolatedZeroCurve< Linear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  arg7 = (Frequency)jarg7; 
  {
    try {
      result = (InterpolatedZeroCurve< Linear > *)new InterpolatedZeroCurve< Linear >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< Linear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  {
    try {
      result = (InterpolatedZeroCurve< Linear > *)new InterpolatedZeroCurve< Linear >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< Linear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (Linear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Linear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< Linear > *)new InterpolatedZeroCurve< Linear >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< Linear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< Linear > *)new InterpolatedZeroCurve< Linear >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< Linear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< Linear > *)new InterpolatedZeroCurve< Linear >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Linear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroCurve_times(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< Linear > *arg1 = (InterpolatedZeroCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((InterpolatedZeroCurve< Linear > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_ZeroCurve_data(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< Linear > *arg1 = (InterpolatedZeroCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedZeroCurve< Linear > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  InterpolatedZeroCurve< Linear > *arg1 = (InterpolatedZeroCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedZeroCurve< Linear > 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_ZeroCurve_zeroRates(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< Linear > *arg1 = (InterpolatedZeroCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Rate > *) &((InterpolatedZeroCurve< Linear > const *)arg1)->zeroRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  InterpolatedZeroCurve< Linear > *arg1 = (InterpolatedZeroCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedZeroCurve< Linear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_ZeroCurve(void * jarg1) {
  InterpolatedZeroCurve< Linear > *arg1 = (InterpolatedZeroCurve< Linear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedZeroCurve<Linear> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Linear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  InterpolatedZeroCurve< LogLinear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (LogLinear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogLinear const & is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  arg7 = (Frequency)jarg7; 
  {
    try {
      result = (InterpolatedZeroCurve< LogLinear > *)new InterpolatedZeroCurve< LogLinear >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< LogLinear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (LogLinear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogLinear const & is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  {
    try {
      result = (InterpolatedZeroCurve< LogLinear > *)new InterpolatedZeroCurve< LogLinear >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< LogLinear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (LogLinear *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogLinear const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< LogLinear > *)new InterpolatedZeroCurve< LogLinear >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< LogLinear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< LogLinear > *)new InterpolatedZeroCurve< LogLinear >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< LogLinear > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< LogLinear > *)new InterpolatedZeroCurve< LogLinear >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogLinearZeroCurve_times(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< LogLinear > *arg1 = (InterpolatedZeroCurve< LogLinear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<LogLinear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((InterpolatedZeroCurve< LogLinear > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogLinearZeroCurve_data(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< LogLinear > *arg1 = (InterpolatedZeroCurve< LogLinear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<LogLinear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedZeroCurve< LogLinear > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  InterpolatedZeroCurve< LogLinear > *arg1 = (InterpolatedZeroCurve< LogLinear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<LogLinear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedZeroCurve< LogLinear > 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_LogLinearZeroCurve_zeroRates(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< LogLinear > *arg1 = (InterpolatedZeroCurve< LogLinear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > const > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<LogLinear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Rate > *) &((InterpolatedZeroCurve< LogLinear > const *)arg1)->zeroRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  InterpolatedZeroCurve< LogLinear > *arg1 = (InterpolatedZeroCurve< LogLinear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<LogLinear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedZeroCurve< LogLinear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LogLinearZeroCurve(void * jarg1) {
  InterpolatedZeroCurve< LogLinear > *arg1 = (InterpolatedZeroCurve< LogLinear > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<LogLinear> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  InterpolatedZeroCurve< Cubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (Cubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  arg7 = (Frequency)jarg7; 
  {
    try {
      result = (InterpolatedZeroCurve< Cubic > *)new InterpolatedZeroCurve< Cubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< Cubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (Cubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  {
    try {
      result = (InterpolatedZeroCurve< Cubic > *)new InterpolatedZeroCurve< Cubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< Cubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (Cubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Cubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< Cubic > *)new InterpolatedZeroCurve< Cubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< Cubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< Cubic > *)new InterpolatedZeroCurve< Cubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< Cubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< Cubic > *)new InterpolatedZeroCurve< Cubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Cubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CubicZeroCurve_times(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< Cubic > *arg1 = (InterpolatedZeroCurve< Cubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Cubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((InterpolatedZeroCurve< Cubic > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_CubicZeroCurve_data(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< Cubic > *arg1 = (InterpolatedZeroCurve< Cubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Cubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedZeroCurve< Cubic > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  InterpolatedZeroCurve< Cubic > *arg1 = (InterpolatedZeroCurve< Cubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Cubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedZeroCurve< Cubic > 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_CubicZeroCurve_zeroRates(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< Cubic > *arg1 = (InterpolatedZeroCurve< Cubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > const > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Cubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Rate > *) &((InterpolatedZeroCurve< Cubic > const *)arg1)->zeroRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  InterpolatedZeroCurve< Cubic > *arg1 = (InterpolatedZeroCurve< Cubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Cubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedZeroCurve< Cubic > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_CubicZeroCurve(void * jarg1) {
  InterpolatedZeroCurve< Cubic > *arg1 = (InterpolatedZeroCurve< Cubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedZeroCurve<Cubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Cubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NaturalCubicZeroCurve__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 ;
  SplineCubic *arg5 = 0 ;
  Compounding arg6 ;
  Frequency arg7 ;
  InterpolatedZeroCurve< SplineCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (SplineCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  arg7 = (Frequency)jarg7; 
  {
    try {
      result = (InterpolatedZeroCurve< SplineCubic > *)new InterpolatedZeroCurve< SplineCubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(SplineCubic 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NaturalCubicZeroCurve__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 ;
  SplineCubic *arg5 = 0 ;
  Compounding arg6 ;
  InterpolatedZeroCurve< SplineCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (SplineCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  {
    try {
      result = (InterpolatedZeroCurve< SplineCubic > *)new InterpolatedZeroCurve< SplineCubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(SplineCubic 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 ? new ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NaturalCubicZeroCurve__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 ;
  SplineCubic *arg5 = 0 ;
  InterpolatedZeroCurve< SplineCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (SplineCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "SplineCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< SplineCubic > *)new InterpolatedZeroCurve< SplineCubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(SplineCubic 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 ? new ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NaturalCubicZeroCurve__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 ;
  InterpolatedZeroCurve< SplineCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< SplineCubic > *)new InterpolatedZeroCurve< SplineCubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_NaturalCubicZeroCurve__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  InterpolatedZeroCurve< SplineCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< SplineCubic > *)new InterpolatedZeroCurve< SplineCubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NaturalCubicZeroCurve_times(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< SplineCubic > *arg1 = (InterpolatedZeroCurve< SplineCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<SplineCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((InterpolatedZeroCurve< SplineCubic > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NaturalCubicZeroCurve_data(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< SplineCubic > *arg1 = (InterpolatedZeroCurve< SplineCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<SplineCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedZeroCurve< SplineCubic > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NaturalCubicZeroCurve_dates(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< SplineCubic > *arg1 = (InterpolatedZeroCurve< SplineCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<SplineCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedZeroCurve< SplineCubic > 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_NaturalCubicZeroCurve_zeroRates(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< SplineCubic > *arg1 = (InterpolatedZeroCurve< SplineCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > const > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<SplineCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Rate > *) &((InterpolatedZeroCurve< SplineCubic > const *)arg1)->zeroRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_NaturalCubicZeroCurve_nodes(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< SplineCubic > *arg1 = (InterpolatedZeroCurve< SplineCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<SplineCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedZeroCurve< SplineCubic > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_NaturalCubicZeroCurve(void * jarg1) {
  InterpolatedZeroCurve< SplineCubic > *arg1 = (InterpolatedZeroCurve< SplineCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<SplineCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  InterpolatedZeroCurve< DefaultLogCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (DefaultLogCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DefaultLogCubic const & is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  arg7 = (Frequency)jarg7; 
  {
    try {
      result = (InterpolatedZeroCurve< DefaultLogCubic > *)new InterpolatedZeroCurve< DefaultLogCubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< DefaultLogCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (DefaultLogCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DefaultLogCubic const & is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  {
    try {
      result = (InterpolatedZeroCurve< DefaultLogCubic > *)new InterpolatedZeroCurve< DefaultLogCubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< DefaultLogCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (DefaultLogCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DefaultLogCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< DefaultLogCubic > *)new InterpolatedZeroCurve< DefaultLogCubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< DefaultLogCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< DefaultLogCubic > *)new InterpolatedZeroCurve< DefaultLogCubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< DefaultLogCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< DefaultLogCubic > *)new InterpolatedZeroCurve< DefaultLogCubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogCubicZeroCurve_times(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< DefaultLogCubic > *arg1 = (InterpolatedZeroCurve< DefaultLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<DefaultLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((InterpolatedZeroCurve< DefaultLogCubic > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_LogCubicZeroCurve_data(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< DefaultLogCubic > *arg1 = (InterpolatedZeroCurve< DefaultLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<DefaultLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedZeroCurve< DefaultLogCubic > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  InterpolatedZeroCurve< DefaultLogCubic > *arg1 = (InterpolatedZeroCurve< DefaultLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<DefaultLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedZeroCurve< DefaultLogCubic > 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_LogCubicZeroCurve_zeroRates(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< DefaultLogCubic > *arg1 = (InterpolatedZeroCurve< DefaultLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > const > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<DefaultLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Rate > *) &((InterpolatedZeroCurve< DefaultLogCubic > const *)arg1)->zeroRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  InterpolatedZeroCurve< DefaultLogCubic > *arg1 = (InterpolatedZeroCurve< DefaultLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<DefaultLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedZeroCurve< DefaultLogCubic > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_LogCubicZeroCurve(void * jarg1) {
  InterpolatedZeroCurve< DefaultLogCubic > *arg1 = (InterpolatedZeroCurve< DefaultLogCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<DefaultLogCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        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 ;
  InterpolatedZeroCurve< MonotonicCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (MonotonicCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  arg7 = (Frequency)jarg7; 
  {
    try {
      result = (InterpolatedZeroCurve< MonotonicCubic > *)new InterpolatedZeroCurve< MonotonicCubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< MonotonicCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (MonotonicCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  {
    try {
      result = (InterpolatedZeroCurve< MonotonicCubic > *)new InterpolatedZeroCurve< MonotonicCubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< MonotonicCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (MonotonicCubic *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "MonotonicCubic const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< MonotonicCubic > *)new InterpolatedZeroCurve< MonotonicCubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< MonotonicCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< MonotonicCubic > *)new InterpolatedZeroCurve< MonotonicCubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  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 ;
  InterpolatedZeroCurve< MonotonicCubic > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< MonotonicCubic > *)new InterpolatedZeroCurve< MonotonicCubic >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MonotonicCubicZeroCurve_times(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< MonotonicCubic > *arg1 = (InterpolatedZeroCurve< MonotonicCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<MonotonicCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((InterpolatedZeroCurve< MonotonicCubic > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_MonotonicCubicZeroCurve_data(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< MonotonicCubic > *arg1 = (InterpolatedZeroCurve< MonotonicCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<MonotonicCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedZeroCurve< MonotonicCubic > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  InterpolatedZeroCurve< MonotonicCubic > *arg1 = (InterpolatedZeroCurve< MonotonicCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<MonotonicCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedZeroCurve< MonotonicCubic > 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_MonotonicCubicZeroCurve_zeroRates(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< MonotonicCubic > *arg1 = (InterpolatedZeroCurve< MonotonicCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > const > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<MonotonicCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Rate > *) &((InterpolatedZeroCurve< MonotonicCubic > const *)arg1)->zeroRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<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 ;
  InterpolatedZeroCurve< MonotonicCubic > *arg1 = (InterpolatedZeroCurve< MonotonicCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<MonotonicCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedZeroCurve< MonotonicCubic > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_MonotonicCubicZeroCurve(void * jarg1) {
  InterpolatedZeroCurve< MonotonicCubic > *arg1 = (InterpolatedZeroCurve< MonotonicCubic > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<MonotonicCubic> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KrugerZeroCurve__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 ;
  Kruger *arg5 = 0 ;
  Compounding arg6 ;
  Frequency arg7 ;
  InterpolatedZeroCurve< Kruger > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (Kruger *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Kruger const & is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  arg7 = (Frequency)jarg7; 
  {
    try {
      result = (InterpolatedZeroCurve< Kruger > *)new InterpolatedZeroCurve< Kruger >((std::vector< Date > const &)*arg1,(std::vector< Rate > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Kruger 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Kruger> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KrugerZeroCurve__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 ;
  Kruger *arg5 = 0 ;
  Compounding arg6 ;
  InterpolatedZeroCurve< Kruger > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (Kruger *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Kruger const & is null", 0);
    return 0;
  } 
  arg6 = (Compounding)jarg6; 
  {
    try {
      result = (InterpolatedZeroCurve< Kruger > *)new InterpolatedZeroCurve< Kruger >((std::vector< Date > const &)*arg1,(std::vector< Rate > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Kruger 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 ? new ext::shared_ptr<  InterpolatedZeroCurve<Kruger> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KrugerZeroCurve__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 ;
  Kruger *arg5 = 0 ;
  InterpolatedZeroCurve< Kruger > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  arg5 = (Kruger *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Kruger const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< Kruger > *)new InterpolatedZeroCurve< Kruger >((std::vector< Date > const &)*arg1,(std::vector< Rate > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Kruger 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 ? new ext::shared_ptr<  InterpolatedZeroCurve<Kruger> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KrugerZeroCurve__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 ;
  InterpolatedZeroCurve< Kruger > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  arg4 = (Calendar *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Calendar const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< Kruger > *)new InterpolatedZeroCurve< Kruger >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Kruger> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_new_KrugerZeroCurve__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  std::vector< Date > *arg1 = 0 ;
  std::vector< Rate > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  InterpolatedZeroCurve< Kruger > *result = 0 ;
  
  arg1 = (std::vector< Date > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Date > const & is null", 0);
    return 0;
  } 
  arg2 = (std::vector< Rate > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Rate > const & is null", 0);
    return 0;
  } 
  arg3 = (DayCounter *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "DayCounter const & is null", 0);
    return 0;
  } 
  {
    try {
      result = (InterpolatedZeroCurve< Kruger > *)new InterpolatedZeroCurve< Kruger >((std::vector< Date > const &)*arg1,(std::vector< Rate > 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 = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Kruger> >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_KrugerZeroCurve_times(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< Kruger > *arg1 = (InterpolatedZeroCurve< Kruger > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > const > *smartarg1 = 0 ;
  std::vector< Time > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Kruger> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Time > *) &((InterpolatedZeroCurve< Kruger > 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 = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_KrugerZeroCurve_data(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< Kruger > *arg1 = (InterpolatedZeroCurve< Kruger > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > const > *smartarg1 = 0 ;
  std::vector< Real > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Kruger> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Real > *) &((InterpolatedZeroCurve< Kruger > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_KrugerZeroCurve_dates(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< Kruger > *arg1 = (InterpolatedZeroCurve< Kruger > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > const > *smartarg1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Kruger> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Date > *) &((InterpolatedZeroCurve< Kruger > 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_KrugerZeroCurve_zeroRates(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< Kruger > *arg1 = (InterpolatedZeroCurve< Kruger > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > const > *smartarg1 = 0 ;
  std::vector< Rate > *result = 0 ;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Kruger> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = (std::vector< Rate > *) &((InterpolatedZeroCurve< Kruger > const *)arg1)->zeroRates();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QuantLib_KrugerZeroCurve_nodes(void * jarg1) {
  void * jresult ;
  InterpolatedZeroCurve< Kruger > *arg1 = (InterpolatedZeroCurve< Kruger > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > const > *smartarg1 = 0 ;
  std::vector< std::pair< Date,Rate > > result;
  
  
  smartarg1 = (ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Kruger> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      result = ((InterpolatedZeroCurve< Kruger > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
      };
    } catch (std::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 > >(result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QuantLib_delete_KrugerZeroCurve(void * jarg1) {
  InterpolatedZeroCurve< Kruger > *arg1 = (InterpolatedZeroCurve< Kruger > *) 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > > *smartarg1 = 0 ;
  
  
  smartarg1 = (ext::shared_ptr<  InterpolatedZeroCurve<Kruger> > *)jarg1;
  arg1 = (InterpolatedZeroCurve<Kruger> *)(smartarg1 ? smartarg1->get() : 0); 
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      {
        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
      };
    } catch (std::exception& e) {
      {
        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
      };
    } catch (...) {
      {
        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
      };
    }
  }
}


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_Austria_SWIGUpcast(QuantLib::Austria *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Botswana_SWIGUpcast(QuantLib::Botswana *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_Chile_SWIGUpcast(QuantLib::Chile *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_France_SWIGUpcast(QuantLib::France *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_Romania_SWIGUpcast(QuantLib::Romania *jarg1) {
    return (Calendar *)jarg1;
}

SWIGEXPORT Calendar * SWIGSTDCALL CSharp_QuantLib_Russia_SWIGUpcast(QuantLib::Russia *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_Thailand_SWIGUpcast(QuantLib::Thailand *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_Actual366_SWIGUpcast(QuantLib::Actual366 *jarg1) {
    return (DayCounter *)jarg1;
}

SWIGEXPORT DayCounter * SWIGSTDCALL CSharp_QuantLib_Actual36525_SWIGUpcast(QuantLib::Actual36525 *jarg1) {
    return (DayCounter *)jarg1;
}

SWIGEXPORT DayCounter * SWIGSTDCALL CSharp_QuantLib_Actual364_SWIGUpcast(QuantLib::Actual364 *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_Thirty365_SWIGUpcast(QuantLib::Thirty365 *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_AEDCurrency_SWIGUpcast(QuantLib::AEDCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_AOACurrency_SWIGUpcast(QuantLib::AOACurrency *jarg1) {
    return (Currency *)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_BHDCurrency_SWIGUpcast(QuantLib::BHDCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_BGLCurrency_SWIGUpcast(QuantLib::BGLCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_BGNCurrency_SWIGUpcast(QuantLib::BGNCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_BRLCurrency_SWIGUpcast(QuantLib::BRLCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_BWPCurrency_SWIGUpcast(QuantLib::BWPCurrency *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_CLFCurrency_SWIGUpcast(QuantLib::CLFCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_CLPCurrency_SWIGUpcast(QuantLib::CLPCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_CNHCurrency_SWIGUpcast(QuantLib::CNHCurrency *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_COUCurrency_SWIGUpcast(QuantLib::COUCurrency *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_EGPCurrency_SWIGUpcast(QuantLib::EGPCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_ESPCurrency_SWIGUpcast(QuantLib::ESPCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_ETBCurrency_SWIGUpcast(QuantLib::ETBCurrency *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_GELCurrency_SWIGUpcast(QuantLib::GELCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_GBPCurrency_SWIGUpcast(QuantLib::GBPCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_GHSCurrency_SWIGUpcast(QuantLib::GHSCurrency *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_HRKCurrency_SWIGUpcast(QuantLib::HRKCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_HUFCurrency_SWIGUpcast(QuantLib::HUFCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_IDRCurrency_SWIGUpcast(QuantLib::IDRCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_IEPCurrency_SWIGUpcast(QuantLib::IEPCurrency *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_JODCurrency_SWIGUpcast(QuantLib::JODCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_JPYCurrency_SWIGUpcast(QuantLib::JPYCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_KESCurrency_SWIGUpcast(QuantLib::KESCurrency *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_KZTCurrency_SWIGUpcast(QuantLib::KZTCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_LKRCurrency_SWIGUpcast(QuantLib::LKRCurrency *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_MADCurrency_SWIGUpcast(QuantLib::MADCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_MTLCurrency_SWIGUpcast(QuantLib::MTLCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_MURCurrency_SWIGUpcast(QuantLib::MURCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_MXNCurrency_SWIGUpcast(QuantLib::MXNCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_MXVCurrency_SWIGUpcast(QuantLib::MXVCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_MYRCurrency_SWIGUpcast(QuantLib::MYRCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_NGNCurrency_SWIGUpcast(QuantLib::NGNCurrency *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_OMRCurrency_SWIGUpcast(QuantLib::OMRCurrency *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_PHPCurrency_SWIGUpcast(QuantLib::PHPCurrency *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_QARCurrency_SWIGUpcast(QuantLib::QARCurrency *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_RSDCurrency_SWIGUpcast(QuantLib::RSDCurrency *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_TNDCurrency_SWIGUpcast(QuantLib::TNDCurrency *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_UAHCurrency_SWIGUpcast(QuantLib::UAHCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_UGXCurrency_SWIGUpcast(QuantLib::UGXCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_USDCurrency_SWIGUpcast(QuantLib::USDCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_UYUCurrency_SWIGUpcast(QuantLib::UYUCurrency *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_XOFCurrency_SWIGUpcast(QuantLib::XOFCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_ZARCurrency_SWIGUpcast(QuantLib::ZARCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_ZMWCurrency_SWIGUpcast(QuantLib::ZMWCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_BCHCurrency_SWIGUpcast(QuantLib::BCHCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_BTCCurrency_SWIGUpcast(QuantLib::BTCCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_DASHCurrency_SWIGUpcast(QuantLib::DASHCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_ETCCurrency_SWIGUpcast(QuantLib::ETCCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_ETHCurrency_SWIGUpcast(QuantLib::ETHCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_LTCCurrency_SWIGUpcast(QuantLib::LTCCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_XRPCurrency_SWIGUpcast(QuantLib::XRPCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT Currency * SWIGSTDCALL CSharp_QuantLib_ZECCurrency_SWIGUpcast(QuantLib::ZECCurrency *jarg1) {
    return (Currency *)jarg1;
}

SWIGEXPORT ext::shared_ptr< Observable > * SWIGSTDCALL CSharp_QuantLib_Quote_SWIGSmartPtrUpcast(ext::shared_ptr< Quote > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Observable >(*jarg1) : 0;
}

SWIGEXPORT Handle< Quote > * SWIGSTDCALL CSharp_QuantLib_RelinkableQuoteHandle_SWIGUpcast(RelinkableHandle< Quote > *jarg1) {
    return (Handle< Quote > *)jarg1;
}

SWIGEXPORT ext::shared_ptr< Quote > * SWIGSTDCALL CSharp_QuantLib_SimpleQuote_SWIGSmartPtrUpcast(ext::shared_ptr< SimpleQuote > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Quote >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Quote > * SWIGSTDCALL CSharp_QuantLib_LastFixingQuote_SWIGSmartPtrUpcast(ext::shared_ptr< LastFixingQuote > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Quote >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Constraint > * SWIGSTDCALL CSharp_QuantLib_BoundaryConstraint_SWIGSmartPtrUpcast(ext::shared_ptr< BoundaryConstraint > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Constraint >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Constraint > * SWIGSTDCALL CSharp_QuantLib_NoConstraint_SWIGSmartPtrUpcast(ext::shared_ptr< NoConstraint > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Constraint >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Constraint > * SWIGSTDCALL CSharp_QuantLib_PositiveConstraint_SWIGSmartPtrUpcast(ext::shared_ptr< PositiveConstraint > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Constraint >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Constraint > * SWIGSTDCALL CSharp_QuantLib_CompositeConstraint_SWIGSmartPtrUpcast(ext::shared_ptr< CompositeConstraint > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Constraint >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Constraint > * SWIGSTDCALL CSharp_QuantLib_NonhomogeneousBoundaryConstraint_SWIGSmartPtrUpcast(ext::shared_ptr< NonhomogeneousBoundaryConstraint > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Constraint >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OptimizationMethod > * SWIGSTDCALL CSharp_QuantLib_ConjugateGradient_SWIGSmartPtrUpcast(ext::shared_ptr< ConjugateGradient > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OptimizationMethod >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OptimizationMethod > * SWIGSTDCALL CSharp_QuantLib_Simplex_SWIGSmartPtrUpcast(ext::shared_ptr< Simplex > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OptimizationMethod >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OptimizationMethod > * SWIGSTDCALL CSharp_QuantLib_SteepestDescent_SWIGSmartPtrUpcast(ext::shared_ptr< SteepestDescent > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OptimizationMethod >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OptimizationMethod > * SWIGSTDCALL CSharp_QuantLib_BFGS_SWIGSmartPtrUpcast(ext::shared_ptr< BFGS > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OptimizationMethod >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OptimizationMethod > * SWIGSTDCALL CSharp_QuantLib_LevenbergMarquardt_SWIGSmartPtrUpcast(ext::shared_ptr< LevenbergMarquardt > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OptimizationMethod >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OptimizationMethod > * SWIGSTDCALL CSharp_QuantLib_DifferentialEvolution_SWIGSmartPtrUpcast(ext::shared_ptr< DifferentialEvolution > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OptimizationMethod >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OptimizationMethod > * SWIGSTDCALL CSharp_QuantLib_GaussianSimulatedAnnealing_SWIGSmartPtrUpcast(ext::shared_ptr< GaussianSimulatedAnnealing > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OptimizationMethod >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OptimizationMethod > * SWIGSTDCALL CSharp_QuantLib_MirrorGaussianSimulatedAnnealing_SWIGSmartPtrUpcast(ext::shared_ptr< MirrorGaussianSimulatedAnnealing > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OptimizationMethod >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OptimizationMethod > * SWIGSTDCALL CSharp_QuantLib_LogNormalSimulatedAnnealing_SWIGSmartPtrUpcast(ext::shared_ptr< LogNormalSimulatedAnnealing > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OptimizationMethod >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Observable > * SWIGSTDCALL CSharp_QuantLib_TermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< TermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Observable >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< TermStructure > * SWIGSTDCALL CSharp_QuantLib_YieldTermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< YieldTermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< TermStructure >(*jarg1) : 0;
}

SWIGEXPORT Handle< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableYieldTermStructureHandle_SWIGUpcast(RelinkableHandle< YieldTermStructure > *jarg1) {
    return (Handle< YieldTermStructure > *)jarg1;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_ImpliedTermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< ImpliedTermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_ZeroSpreadedTermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< ZeroSpreadedTermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_ForwardSpreadedTermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< ForwardSpreadedTermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseZeroSpreadedTermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseZeroSpreadedTermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_SpreadedLinearZeroInterpolatedTermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< SpreadedLinearZeroInterpolatedTermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_SpreadedBackwardFlatZeroInterpolatedTermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< SpreadedBackwardFlatZeroInterpolatedTermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_FlatForward_SWIGSmartPtrUpcast(ext::shared_ptr< FlatForward > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_UltimateForwardTermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< UltimateForwardTermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_QuantoTermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< QuantoTermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Observable > * SWIGSTDCALL CSharp_QuantLib_Index_SWIGSmartPtrUpcast(ext::shared_ptr< Index > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Observable >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Index > * SWIGSTDCALL CSharp_QuantLib_InterestRateIndex_SWIGSmartPtrUpcast(ext::shared_ptr< InterestRateIndex > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Index >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< InterestRateIndex > * SWIGSTDCALL CSharp_QuantLib_IborIndex_SWIGSmartPtrUpcast(ext::shared_ptr< IborIndex > *jarg1) {
    return jarg1 ? new ext::shared_ptr< InterestRateIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_OvernightIndex_SWIGSmartPtrUpcast(ext::shared_ptr< OvernightIndex > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_Libor_SWIGSmartPtrUpcast(ext::shared_ptr< Libor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_DailyTenorLibor_SWIGSmartPtrUpcast(ext::shared_ptr< DailyTenorLibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< InterestRateIndex > * SWIGSTDCALL CSharp_QuantLib_SwapIndex_SWIGSmartPtrUpcast(ext::shared_ptr< SwapIndex > *jarg1) {
    return jarg1 ? new ext::shared_ptr< InterestRateIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< InterestRateIndex > * SWIGSTDCALL CSharp_QuantLib_SwapSpreadIndex_SWIGSmartPtrUpcast(ext::shared_ptr< SwapSpreadIndex > *jarg1) {
    return jarg1 ? new ext::shared_ptr< InterestRateIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Index > * SWIGSTDCALL CSharp_QuantLib_EquityIndex_SWIGSmartPtrUpcast(ext::shared_ptr< EquityIndex > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Index >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_AUDLibor_SWIGSmartPtrUpcast(ext::shared_ptr< AUDLibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_CADLibor_SWIGSmartPtrUpcast(ext::shared_ptr< CADLibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< DailyTenorLibor > * SWIGSTDCALL CSharp_QuantLib_CADLiborON_SWIGSmartPtrUpcast(ext::shared_ptr< CADLiborON > *jarg1) {
    return jarg1 ? new ext::shared_ptr< DailyTenorLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_Cdor_SWIGSmartPtrUpcast(ext::shared_ptr< Cdor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_CHFLibor_SWIGSmartPtrUpcast(ext::shared_ptr< CHFLibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_DKKLibor_SWIGSmartPtrUpcast(ext::shared_ptr< DKKLibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_Bbsw_SWIGSmartPtrUpcast(ext::shared_ptr< Bbsw > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bbsw > * SWIGSTDCALL CSharp_QuantLib_Bbsw1M_SWIGSmartPtrUpcast(ext::shared_ptr< Bbsw1M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bbsw >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bbsw > * SWIGSTDCALL CSharp_QuantLib_Bbsw2M_SWIGSmartPtrUpcast(ext::shared_ptr< Bbsw2M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bbsw >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bbsw > * SWIGSTDCALL CSharp_QuantLib_Bbsw3M_SWIGSmartPtrUpcast(ext::shared_ptr< Bbsw3M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bbsw >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bbsw > * SWIGSTDCALL CSharp_QuantLib_Bbsw4M_SWIGSmartPtrUpcast(ext::shared_ptr< Bbsw4M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bbsw >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bbsw > * SWIGSTDCALL CSharp_QuantLib_Bbsw5M_SWIGSmartPtrUpcast(ext::shared_ptr< Bbsw5M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bbsw >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bbsw > * SWIGSTDCALL CSharp_QuantLib_Bbsw6M_SWIGSmartPtrUpcast(ext::shared_ptr< Bbsw6M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bbsw >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_Bkbm_SWIGSmartPtrUpcast(ext::shared_ptr< Bkbm > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bkbm > * SWIGSTDCALL CSharp_QuantLib_Bkbm1M_SWIGSmartPtrUpcast(ext::shared_ptr< Bkbm1M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bkbm >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bkbm > * SWIGSTDCALL CSharp_QuantLib_Bkbm2M_SWIGSmartPtrUpcast(ext::shared_ptr< Bkbm2M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bkbm >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bkbm > * SWIGSTDCALL CSharp_QuantLib_Bkbm3M_SWIGSmartPtrUpcast(ext::shared_ptr< Bkbm3M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bkbm >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bkbm > * SWIGSTDCALL CSharp_QuantLib_Bkbm4M_SWIGSmartPtrUpcast(ext::shared_ptr< Bkbm4M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bkbm >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bkbm > * SWIGSTDCALL CSharp_QuantLib_Bkbm5M_SWIGSmartPtrUpcast(ext::shared_ptr< Bkbm5M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bkbm >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bkbm > * SWIGSTDCALL CSharp_QuantLib_Bkbm6M_SWIGSmartPtrUpcast(ext::shared_ptr< Bkbm6M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bkbm >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_Euribor_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor > * SWIGSTDCALL CSharp_QuantLib_EuriborSW_SWIGSmartPtrUpcast(ext::shared_ptr< EuriborSW > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor > * SWIGSTDCALL CSharp_QuantLib_Euribor2W_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor2W > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor > * SWIGSTDCALL CSharp_QuantLib_Euribor3W_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor3W > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor > * SWIGSTDCALL CSharp_QuantLib_Euribor1M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor1M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor > * SWIGSTDCALL CSharp_QuantLib_Euribor2M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor2M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor > * SWIGSTDCALL CSharp_QuantLib_Euribor3M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor3M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor > * SWIGSTDCALL CSharp_QuantLib_Euribor4M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor4M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor > * SWIGSTDCALL CSharp_QuantLib_Euribor5M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor5M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor > * SWIGSTDCALL CSharp_QuantLib_Euribor6M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor6M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor > * SWIGSTDCALL CSharp_QuantLib_Euribor7M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor7M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor > * SWIGSTDCALL CSharp_QuantLib_Euribor8M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor8M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor > * SWIGSTDCALL CSharp_QuantLib_Euribor9M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor9M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor > * SWIGSTDCALL CSharp_QuantLib_Euribor10M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor10M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor > * SWIGSTDCALL CSharp_QuantLib_Euribor11M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor11M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor > * SWIGSTDCALL CSharp_QuantLib_Euribor1Y_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor1Y > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_Euribor365_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor365 > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor365 > * SWIGSTDCALL CSharp_QuantLib_Euribor365_SW_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor365_SW > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor365 >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor365 > * SWIGSTDCALL CSharp_QuantLib_Euribor365_2W_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor365_2W > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor365 >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor365 > * SWIGSTDCALL CSharp_QuantLib_Euribor365_3W_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor365_3W > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor365 >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor365 > * SWIGSTDCALL CSharp_QuantLib_Euribor365_1M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor365_1M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor365 >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor365 > * SWIGSTDCALL CSharp_QuantLib_Euribor365_2M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor365_2M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor365 >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor365 > * SWIGSTDCALL CSharp_QuantLib_Euribor365_3M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor365_3M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor365 >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor365 > * SWIGSTDCALL CSharp_QuantLib_Euribor365_4M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor365_4M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor365 >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor365 > * SWIGSTDCALL CSharp_QuantLib_Euribor365_5M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor365_5M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor365 >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor365 > * SWIGSTDCALL CSharp_QuantLib_Euribor365_6M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor365_6M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor365 >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor365 > * SWIGSTDCALL CSharp_QuantLib_Euribor365_7M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor365_7M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor365 >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor365 > * SWIGSTDCALL CSharp_QuantLib_Euribor365_8M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor365_8M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor365 >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor365 > * SWIGSTDCALL CSharp_QuantLib_Euribor365_9M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor365_9M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor365 >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor365 > * SWIGSTDCALL CSharp_QuantLib_Euribor365_10M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor365_10M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor365 >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor365 > * SWIGSTDCALL CSharp_QuantLib_Euribor365_11M_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor365_11M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor365 >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Euribor365 > * SWIGSTDCALL CSharp_QuantLib_Euribor365_1Y_SWIGSmartPtrUpcast(ext::shared_ptr< Euribor365_1Y > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Euribor365 >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_EURLibor_SWIGSmartPtrUpcast(ext::shared_ptr< EURLibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< EURLibor > * SWIGSTDCALL CSharp_QuantLib_EURLiborSW_SWIGSmartPtrUpcast(ext::shared_ptr< EURLiborSW > *jarg1) {
    return jarg1 ? new ext::shared_ptr< EURLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< EURLibor > * SWIGSTDCALL CSharp_QuantLib_EURLibor2W_SWIGSmartPtrUpcast(ext::shared_ptr< EURLibor2W > *jarg1) {
    return jarg1 ? new ext::shared_ptr< EURLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< EURLibor > * SWIGSTDCALL CSharp_QuantLib_EURLibor1M_SWIGSmartPtrUpcast(ext::shared_ptr< EURLibor1M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< EURLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< EURLibor > * SWIGSTDCALL CSharp_QuantLib_EURLibor2M_SWIGSmartPtrUpcast(ext::shared_ptr< EURLibor2M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< EURLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< EURLibor > * SWIGSTDCALL CSharp_QuantLib_EURLibor3M_SWIGSmartPtrUpcast(ext::shared_ptr< EURLibor3M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< EURLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< EURLibor > * SWIGSTDCALL CSharp_QuantLib_EURLibor4M_SWIGSmartPtrUpcast(ext::shared_ptr< EURLibor4M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< EURLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< EURLibor > * SWIGSTDCALL CSharp_QuantLib_EURLibor5M_SWIGSmartPtrUpcast(ext::shared_ptr< EURLibor5M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< EURLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< EURLibor > * SWIGSTDCALL CSharp_QuantLib_EURLibor6M_SWIGSmartPtrUpcast(ext::shared_ptr< EURLibor6M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< EURLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< EURLibor > * SWIGSTDCALL CSharp_QuantLib_EURLibor7M_SWIGSmartPtrUpcast(ext::shared_ptr< EURLibor7M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< EURLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< EURLibor > * SWIGSTDCALL CSharp_QuantLib_EURLibor8M_SWIGSmartPtrUpcast(ext::shared_ptr< EURLibor8M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< EURLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< EURLibor > * SWIGSTDCALL CSharp_QuantLib_EURLibor9M_SWIGSmartPtrUpcast(ext::shared_ptr< EURLibor9M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< EURLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< EURLibor > * SWIGSTDCALL CSharp_QuantLib_EURLibor10M_SWIGSmartPtrUpcast(ext::shared_ptr< EURLibor10M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< EURLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< EURLibor > * SWIGSTDCALL CSharp_QuantLib_EURLibor11M_SWIGSmartPtrUpcast(ext::shared_ptr< EURLibor11M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< EURLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< EURLibor > * SWIGSTDCALL CSharp_QuantLib_EURLibor1Y_SWIGSmartPtrUpcast(ext::shared_ptr< EURLibor1Y > *jarg1) {
    return jarg1 ? new ext::shared_ptr< EURLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_GBPLibor_SWIGSmartPtrUpcast(ext::shared_ptr< GBPLibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< DailyTenorLibor > * SWIGSTDCALL CSharp_QuantLib_GBPLiborON_SWIGSmartPtrUpcast(ext::shared_ptr< GBPLiborON > *jarg1) {
    return jarg1 ? new ext::shared_ptr< DailyTenorLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_Jibar_SWIGSmartPtrUpcast(ext::shared_ptr< Jibar > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_JPYLibor_SWIGSmartPtrUpcast(ext::shared_ptr< JPYLibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_Mosprime_SWIGSmartPtrUpcast(ext::shared_ptr< Mosprime > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_NZDLibor_SWIGSmartPtrUpcast(ext::shared_ptr< NZDLibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_Pribor_SWIGSmartPtrUpcast(ext::shared_ptr< Pribor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_Robor_SWIGSmartPtrUpcast(ext::shared_ptr< Robor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_SEKLibor_SWIGSmartPtrUpcast(ext::shared_ptr< SEKLibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_Shibor_SWIGSmartPtrUpcast(ext::shared_ptr< Shibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_Tibor_SWIGSmartPtrUpcast(ext::shared_ptr< Tibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_THBFIX_SWIGSmartPtrUpcast(ext::shared_ptr< THBFIX > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_TRLibor_SWIGSmartPtrUpcast(ext::shared_ptr< TRLibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_USDLibor_SWIGSmartPtrUpcast(ext::shared_ptr< USDLibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< DailyTenorLibor > * SWIGSTDCALL CSharp_QuantLib_USDLiborON_SWIGSmartPtrUpcast(ext::shared_ptr< USDLiborON > *jarg1) {
    return jarg1 ? new ext::shared_ptr< DailyTenorLibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_Wibor_SWIGSmartPtrUpcast(ext::shared_ptr< Wibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_Zibor_SWIGSmartPtrUpcast(ext::shared_ptr< Zibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OvernightIndex > * SWIGSTDCALL CSharp_QuantLib_Aonia_SWIGSmartPtrUpcast(ext::shared_ptr< Aonia > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OvernightIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OvernightIndex > * SWIGSTDCALL CSharp_QuantLib_Corra_SWIGSmartPtrUpcast(ext::shared_ptr< Corra > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OvernightIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OvernightIndex > * SWIGSTDCALL CSharp_QuantLib_Destr_SWIGSmartPtrUpcast(ext::shared_ptr< Destr > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OvernightIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OvernightIndex > * SWIGSTDCALL CSharp_QuantLib_Eonia_SWIGSmartPtrUpcast(ext::shared_ptr< Eonia > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OvernightIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OvernightIndex > * SWIGSTDCALL CSharp_QuantLib_Estr_SWIGSmartPtrUpcast(ext::shared_ptr< Estr > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OvernightIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OvernightIndex > * SWIGSTDCALL CSharp_QuantLib_FedFunds_SWIGSmartPtrUpcast(ext::shared_ptr< FedFunds > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OvernightIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OvernightIndex > * SWIGSTDCALL CSharp_QuantLib_Nzocr_SWIGSmartPtrUpcast(ext::shared_ptr< Nzocr > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OvernightIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OvernightIndex > * SWIGSTDCALL CSharp_QuantLib_Sofr_SWIGSmartPtrUpcast(ext::shared_ptr< Sofr > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OvernightIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OvernightIndex > * SWIGSTDCALL CSharp_QuantLib_Sonia_SWIGSmartPtrUpcast(ext::shared_ptr< Sonia > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OvernightIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OvernightIndex > * SWIGSTDCALL CSharp_QuantLib_Swestr_SWIGSmartPtrUpcast(ext::shared_ptr< Swestr > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OvernightIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwapIndex > * SWIGSTDCALL CSharp_QuantLib_EuriborSwapIsdaFixA_SWIGSmartPtrUpcast(ext::shared_ptr< EuriborSwapIsdaFixA > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwapIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwapIndex > * SWIGSTDCALL CSharp_QuantLib_EuriborSwapIsdaFixB_SWIGSmartPtrUpcast(ext::shared_ptr< EuriborSwapIsdaFixB > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwapIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwapIndex > * SWIGSTDCALL CSharp_QuantLib_EuriborSwapIfrFix_SWIGSmartPtrUpcast(ext::shared_ptr< EuriborSwapIfrFix > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwapIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwapIndex > * SWIGSTDCALL CSharp_QuantLib_EurLiborSwapIsdaFixA_SWIGSmartPtrUpcast(ext::shared_ptr< EurLiborSwapIsdaFixA > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwapIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwapIndex > * SWIGSTDCALL CSharp_QuantLib_EurLiborSwapIsdaFixB_SWIGSmartPtrUpcast(ext::shared_ptr< EurLiborSwapIsdaFixB > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwapIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwapIndex > * SWIGSTDCALL CSharp_QuantLib_EurLiborSwapIfrFix_SWIGSmartPtrUpcast(ext::shared_ptr< EurLiborSwapIfrFix > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwapIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwapIndex > * SWIGSTDCALL CSharp_QuantLib_ChfLiborSwapIsdaFix_SWIGSmartPtrUpcast(ext::shared_ptr< ChfLiborSwapIsdaFix > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwapIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwapIndex > * SWIGSTDCALL CSharp_QuantLib_GbpLiborSwapIsdaFix_SWIGSmartPtrUpcast(ext::shared_ptr< GbpLiborSwapIsdaFix > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwapIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwapIndex > * SWIGSTDCALL CSharp_QuantLib_JpyLiborSwapIsdaFixAm_SWIGSmartPtrUpcast(ext::shared_ptr< JpyLiborSwapIsdaFixAm > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwapIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwapIndex > * SWIGSTDCALL CSharp_QuantLib_JpyLiborSwapIsdaFixPm_SWIGSmartPtrUpcast(ext::shared_ptr< JpyLiborSwapIsdaFixPm > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwapIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwapIndex > * SWIGSTDCALL CSharp_QuantLib_UsdLiborSwapIsdaFixAm_SWIGSmartPtrUpcast(ext::shared_ptr< UsdLiborSwapIsdaFixAm > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwapIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwapIndex > * SWIGSTDCALL CSharp_QuantLib_UsdLiborSwapIsdaFixPm_SWIGSmartPtrUpcast(ext::shared_ptr< UsdLiborSwapIsdaFixPm > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwapIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborIndex > * SWIGSTDCALL CSharp_QuantLib_Bibor_SWIGSmartPtrUpcast(ext::shared_ptr< Bibor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bibor > * SWIGSTDCALL CSharp_QuantLib_BiborSW_SWIGSmartPtrUpcast(ext::shared_ptr< BiborSW > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bibor > * SWIGSTDCALL CSharp_QuantLib_Bibor1M_SWIGSmartPtrUpcast(ext::shared_ptr< Bibor1M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bibor > * SWIGSTDCALL CSharp_QuantLib_Bibor2M_SWIGSmartPtrUpcast(ext::shared_ptr< Bibor2M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bibor > * SWIGSTDCALL CSharp_QuantLib_Bibor3M_SWIGSmartPtrUpcast(ext::shared_ptr< Bibor3M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bibor > * SWIGSTDCALL CSharp_QuantLib_Bibor6M_SWIGSmartPtrUpcast(ext::shared_ptr< Bibor6M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bibor > * SWIGSTDCALL CSharp_QuantLib_Bibor9M_SWIGSmartPtrUpcast(ext::shared_ptr< Bibor9M > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bibor > * SWIGSTDCALL CSharp_QuantLib_Bibor1Y_SWIGSmartPtrUpcast(ext::shared_ptr< Bibor1Y > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bibor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< TermStructure > * SWIGSTDCALL CSharp_QuantLib_VolatilityTermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< VolatilityTermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< TermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< VolatilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_BlackVolTermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< BlackVolTermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< VolatilityTermStructure >(*jarg1) : 0;
}

SWIGEXPORT Handle< BlackVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableBlackVolTermStructureHandle_SWIGUpcast(RelinkableHandle< BlackVolTermStructure > *jarg1) {
    return (Handle< BlackVolTermStructure > *)jarg1;
}

SWIGEXPORT ext::shared_ptr< VolatilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_LocalVolTermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< LocalVolTermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< VolatilityTermStructure >(*jarg1) : 0;
}

SWIGEXPORT Handle< LocalVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableLocalVolTermStructureHandle_SWIGUpcast(RelinkableHandle< LocalVolTermStructure > *jarg1) {
    return (Handle< LocalVolTermStructure > *)jarg1;
}

SWIGEXPORT ext::shared_ptr< VolatilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_OptionletVolatilityStructure_SWIGSmartPtrUpcast(ext::shared_ptr< OptionletVolatilityStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< VolatilityTermStructure >(*jarg1) : 0;
}

SWIGEXPORT Handle< OptionletVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableOptionletVolatilityStructureHandle_SWIGUpcast(RelinkableHandle< OptionletVolatilityStructure > *jarg1) {
    return (Handle< OptionletVolatilityStructure > *)jarg1;
}

SWIGEXPORT ext::shared_ptr< VolatilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_YoYOptionletVolatilitySurface_SWIGSmartPtrUpcast(ext::shared_ptr< YoYOptionletVolatilitySurface > *jarg1) {
    return jarg1 ? new ext::shared_ptr< VolatilityTermStructure >(*jarg1) : 0;
}

SWIGEXPORT Handle< YoYOptionletVolatilitySurface > * SWIGSTDCALL CSharp_QuantLib_RelinkableYoYOptionletVolatilitySurfaceHandle_SWIGUpcast(RelinkableHandle< YoYOptionletVolatilitySurface > *jarg1) {
    return (Handle< YoYOptionletVolatilitySurface > *)jarg1;
}

SWIGEXPORT ext::shared_ptr< Observable > * SWIGSTDCALL CSharp_QuantLib_SmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< SmileSection > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Observable >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< VolatilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityStructure_SWIGSmartPtrUpcast(ext::shared_ptr< SwaptionVolatilityStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< VolatilityTermStructure >(*jarg1) : 0;
}

SWIGEXPORT Handle< SwaptionVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableSwaptionVolatilityStructureHandle_SWIGUpcast(RelinkableHandle< SwaptionVolatilityStructure > *jarg1) {
    return (Handle< SwaptionVolatilityStructure > *)jarg1;
}

SWIGEXPORT ext::shared_ptr< BlackVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_BlackConstantVol_SWIGSmartPtrUpcast(ext::shared_ptr< BlackConstantVol > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BlackVolTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BlackVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_BlackVarianceCurve_SWIGSmartPtrUpcast(ext::shared_ptr< BlackVarianceCurve > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BlackVolTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BlackVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_BlackVarianceSurface_SWIGSmartPtrUpcast(ext::shared_ptr< BlackVarianceSurface > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BlackVolTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OptionletVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_ConstantOptionletVolatility_SWIGSmartPtrUpcast(ext::shared_ptr< ConstantOptionletVolatility > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OptionletVolatilityStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwaptionVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_ConstantSwaptionVolatility_SWIGSmartPtrUpcast(ext::shared_ptr< ConstantSwaptionVolatility > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwaptionVolatilityStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwaptionVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityDiscrete_SWIGSmartPtrUpcast(ext::shared_ptr< SwaptionVolatilityDiscrete > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwaptionVolatilityStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwaptionVolatilityDiscrete > * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityMatrix_SWIGSmartPtrUpcast(ext::shared_ptr< SwaptionVolatilityMatrix > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwaptionVolatilityDiscrete >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_SabrSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< SabrSmileSection > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_SviSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< SviSmileSection > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_SviInterpolatedSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< SviInterpolatedSmileSection > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwaptionVolatilityDiscrete > * SWIGSTDCALL CSharp_QuantLib_SwaptionVolatilityCube_SWIGSmartPtrUpcast(ext::shared_ptr< SwaptionVolatilityCube > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwaptionVolatilityDiscrete >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwaptionVolatilityCube > * SWIGSTDCALL CSharp_QuantLib_SabrSwaptionVolatilityCube_SWIGSmartPtrUpcast(ext::shared_ptr< SabrSwaptionVolatilityCube > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwaptionVolatilityCube >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwaptionVolatilityCube > * SWIGSTDCALL CSharp_QuantLib_InterpolatedSwaptionVolatilityCube_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedSwaptionVolatilityCube > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwaptionVolatilityCube >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYOptionletVolatilitySurface > * SWIGSTDCALL CSharp_QuantLib_ConstantYoYOptionletVolatility_SWIGSmartPtrUpcast(ext::shared_ptr< ConstantYoYOptionletVolatility > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYOptionletVolatilitySurface >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_FlatSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< FlatSmileSection > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_LinearInterpolatedSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedSmileSection< Linear > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_CubicInterpolatedSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedSmileSection< Cubic > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_MonotonicCubicInterpolatedSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedSmileSection< MonotonicCubic > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_SplineCubicInterpolatedSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedSmileSection< SplineCubic > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_KahaleSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< KahaleSmileSection > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_ZabrShortMaturityLognormalSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< ZabrSmileSection< ZabrShortMaturityLognormal > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_ZabrShortMaturityNormalSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< ZabrSmileSection< ZabrShortMaturityNormal > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_ZabrLocalVolatilitySmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< ZabrSmileSection< ZabrLocalVolatility > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_ZabrFullFdSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< ZabrSmileSection< ZabrFullFd > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_ZabrShortMaturityLognormalInterpolatedSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_ZabrShortMaturityNormalInterpolatedSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_ZabrLocalVolatilityInterpolatedSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_ZabrFullFdInterpolatedSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_NoArbSabrSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< NoArbSabrSmileSection > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SmileSection > * SWIGSTDCALL CSharp_QuantLib_NoArbSabrInterpolatedSmileSection_SWIGSmartPtrUpcast(ext::shared_ptr< NoArbSabrInterpolatedSmileSection > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SmileSection >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Observable > * SWIGSTDCALL CSharp_QuantLib_AndreasenHugeVolatilityInterpl_SWIGSmartPtrUpcast(ext::shared_ptr< AndreasenHugeVolatilityInterpl > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Observable >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BlackVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_AndreasenHugeVolatilityAdapter_SWIGSmartPtrUpcast(ext::shared_ptr< AndreasenHugeVolatilityAdapter > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BlackVolTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< LocalVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_AndreasenHugeLocalVolAdapter_SWIGSmartPtrUpcast(ext::shared_ptr< AndreasenHugeLocalVolAdapter > *jarg1) {
    return jarg1 ? new ext::shared_ptr< LocalVolTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BlackVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_HestonBlackVolSurface_SWIGSmartPtrUpcast(ext::shared_ptr< HestonBlackVolSurface > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BlackVolTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Observable > * SWIGSTDCALL CSharp_QuantLib_CashFlow_SWIGSmartPtrUpcast(ext::shared_ptr< CashFlow > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Observable >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CashFlow > * SWIGSTDCALL CSharp_QuantLib_SimpleCashFlow_SWIGSmartPtrUpcast(ext::shared_ptr< SimpleCashFlow > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CashFlow >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CashFlow > * SWIGSTDCALL CSharp_QuantLib_Redemption_SWIGSmartPtrUpcast(ext::shared_ptr< Redemption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CashFlow >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CashFlow > * SWIGSTDCALL CSharp_QuantLib_AmortizingPayment_SWIGSmartPtrUpcast(ext::shared_ptr< AmortizingPayment > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CashFlow >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CashFlow > * SWIGSTDCALL CSharp_QuantLib_IndexedCashFlow_SWIGSmartPtrUpcast(ext::shared_ptr< IndexedCashFlow > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CashFlow >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CashFlow > * SWIGSTDCALL CSharp_QuantLib_Coupon_SWIGSmartPtrUpcast(ext::shared_ptr< Coupon > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CashFlow >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Coupon > * SWIGSTDCALL CSharp_QuantLib_FixedRateCoupon_SWIGSmartPtrUpcast(ext::shared_ptr< FixedRateCoupon > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Coupon >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Coupon > * SWIGSTDCALL CSharp_QuantLib_FloatingRateCoupon_SWIGSmartPtrUpcast(ext::shared_ptr< FloatingRateCoupon > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Coupon >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FloatingRateCoupon > * SWIGSTDCALL CSharp_QuantLib_OvernightIndexedCoupon_SWIGSmartPtrUpcast(ext::shared_ptr< OvernightIndexedCoupon > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FloatingRateCoupon >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FloatingRateCoupon > * SWIGSTDCALL CSharp_QuantLib_CappedFlooredCoupon_SWIGSmartPtrUpcast(ext::shared_ptr< CappedFlooredCoupon > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FloatingRateCoupon >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FloatingRateCoupon > * SWIGSTDCALL CSharp_QuantLib_IborCoupon_SWIGSmartPtrUpcast(ext::shared_ptr< IborCoupon > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FloatingRateCoupon >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CappedFlooredCoupon > * SWIGSTDCALL CSharp_QuantLib_CappedFlooredIborCoupon_SWIGSmartPtrUpcast(ext::shared_ptr< CappedFlooredIborCoupon > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CappedFlooredCoupon >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FloatingRateCoupon > * SWIGSTDCALL CSharp_QuantLib_SubPeriodsCoupon_SWIGSmartPtrUpcast(ext::shared_ptr< SubPeriodsCoupon > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FloatingRateCoupon >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FloatingRateCouponPricer > * SWIGSTDCALL CSharp_QuantLib_IborCouponPricer_SWIGSmartPtrUpcast(ext::shared_ptr< IborCouponPricer > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FloatingRateCouponPricer >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IborCouponPricer > * SWIGSTDCALL CSharp_QuantLib_BlackIborCouponPricer_SWIGSmartPtrUpcast(ext::shared_ptr< BlackIborCouponPricer > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IborCouponPricer >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FloatingRateCouponPricer > * SWIGSTDCALL CSharp_QuantLib_SubPeriodsPricer_SWIGSmartPtrUpcast(ext::shared_ptr< SubPeriodsPricer > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FloatingRateCouponPricer >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SubPeriodsPricer > * SWIGSTDCALL CSharp_QuantLib_CompoundingRatePricer_SWIGSmartPtrUpcast(ext::shared_ptr< CompoundingRatePricer > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SubPeriodsPricer >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SubPeriodsPricer > * SWIGSTDCALL CSharp_QuantLib_AveragingRatePricer_SWIGSmartPtrUpcast(ext::shared_ptr< AveragingRatePricer > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SubPeriodsPricer >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FloatingRateCoupon > * SWIGSTDCALL CSharp_QuantLib_CmsCoupon_SWIGSmartPtrUpcast(ext::shared_ptr< CmsCoupon > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FloatingRateCoupon >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FloatingRateCoupon > * SWIGSTDCALL CSharp_QuantLib_CmsSpreadCoupon_SWIGSmartPtrUpcast(ext::shared_ptr< CmsSpreadCoupon > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FloatingRateCoupon >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FloatingRateCouponPricer > * SWIGSTDCALL CSharp_QuantLib_CmsCouponPricer_SWIGSmartPtrUpcast(ext::shared_ptr< CmsCouponPricer > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FloatingRateCouponPricer >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CmsCouponPricer > * SWIGSTDCALL CSharp_QuantLib_AnalyticHaganPricer_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticHaganPricer > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CmsCouponPricer >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CmsCouponPricer > * SWIGSTDCALL CSharp_QuantLib_NumericHaganPricer_SWIGSmartPtrUpcast(ext::shared_ptr< NumericHaganPricer > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CmsCouponPricer >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CappedFlooredCoupon > * SWIGSTDCALL CSharp_QuantLib_CappedFlooredCmsCoupon_SWIGSmartPtrUpcast(ext::shared_ptr< CappedFlooredCmsCoupon > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CappedFlooredCoupon >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CappedFlooredCoupon > * SWIGSTDCALL CSharp_QuantLib_CappedFlooredCmsSpreadCoupon_SWIGSmartPtrUpcast(ext::shared_ptr< CappedFlooredCmsSpreadCoupon > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CappedFlooredCoupon >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CmsCouponPricer > * SWIGSTDCALL CSharp_QuantLib_LinearTsrPricer_SWIGSmartPtrUpcast(ext::shared_ptr< LinearTsrPricer > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CmsCouponPricer >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FloatingRateCouponPricer > * SWIGSTDCALL CSharp_QuantLib_CmsSpreadCouponPricer_SWIGSmartPtrUpcast(ext::shared_ptr< CmsSpreadCouponPricer > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FloatingRateCouponPricer >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CmsSpreadCouponPricer > * SWIGSTDCALL CSharp_QuantLib_LognormalCmsSpreadPricer_SWIGSmartPtrUpcast(ext::shared_ptr< LognormalCmsSpreadPricer > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CmsSpreadCouponPricer >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IndexedCashFlow > * SWIGSTDCALL CSharp_QuantLib_EquityCashFlow_SWIGSmartPtrUpcast(ext::shared_ptr< EquityCashFlow > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IndexedCashFlow >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< EquityCashFlowPricer > * SWIGSTDCALL CSharp_QuantLib_EquityQuantoCashFlowPricer_SWIGSmartPtrUpcast(ext::shared_ptr< EquityQuantoCashFlowPricer > *jarg1) {
    return jarg1 ? new ext::shared_ptr< EquityCashFlowPricer >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CashFlow > * SWIGSTDCALL CSharp_QuantLib_Dividend_SWIGSmartPtrUpcast(ext::shared_ptr< Dividend > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CashFlow >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Dividend > * SWIGSTDCALL CSharp_QuantLib_FixedDividend_SWIGSmartPtrUpcast(ext::shared_ptr< FixedDividend > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Dividend >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Dividend > * SWIGSTDCALL CSharp_QuantLib_FractionalDividend_SWIGSmartPtrUpcast(ext::shared_ptr< FractionalDividend > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Dividend >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Exercise > * SWIGSTDCALL CSharp_QuantLib_EuropeanExercise_SWIGSmartPtrUpcast(ext::shared_ptr< EuropeanExercise > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Exercise >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Exercise > * SWIGSTDCALL CSharp_QuantLib_AmericanExercise_SWIGSmartPtrUpcast(ext::shared_ptr< AmericanExercise > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Exercise >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Exercise > * SWIGSTDCALL CSharp_QuantLib_BermudanExercise_SWIGSmartPtrUpcast(ext::shared_ptr< BermudanExercise > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Exercise >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Exercise > * SWIGSTDCALL CSharp_QuantLib_RebatedExercise_SWIGSmartPtrUpcast(ext::shared_ptr< RebatedExercise > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Exercise >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Exercise > * SWIGSTDCALL CSharp_QuantLib_SwingExercise_SWIGSmartPtrUpcast(ext::shared_ptr< SwingExercise > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Exercise >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Observable > * SWIGSTDCALL CSharp_QuantLib_StochasticProcess_SWIGSmartPtrUpcast(ext::shared_ptr< StochasticProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Observable >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess > * SWIGSTDCALL CSharp_QuantLib_StochasticProcess1D_SWIGSmartPtrUpcast(ext::shared_ptr< StochasticProcess1D > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess1D > * SWIGSTDCALL CSharp_QuantLib_GeneralizedBlackScholesProcess_SWIGSmartPtrUpcast(ext::shared_ptr< GeneralizedBlackScholesProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess1D >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< GeneralizedBlackScholesProcess > * SWIGSTDCALL CSharp_QuantLib_BlackScholesProcess_SWIGSmartPtrUpcast(ext::shared_ptr< BlackScholesProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< GeneralizedBlackScholesProcess >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< GeneralizedBlackScholesProcess > * SWIGSTDCALL CSharp_QuantLib_BlackScholesMertonProcess_SWIGSmartPtrUpcast(ext::shared_ptr< BlackScholesMertonProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< GeneralizedBlackScholesProcess >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< GeneralizedBlackScholesProcess > * SWIGSTDCALL CSharp_QuantLib_BlackProcess_SWIGSmartPtrUpcast(ext::shared_ptr< BlackProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< GeneralizedBlackScholesProcess >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< GeneralizedBlackScholesProcess > * SWIGSTDCALL CSharp_QuantLib_GarmanKohlagenProcess_SWIGSmartPtrUpcast(ext::shared_ptr< GarmanKohlagenProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< GeneralizedBlackScholesProcess >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess1D > * SWIGSTDCALL CSharp_QuantLib_Merton76Process_SWIGSmartPtrUpcast(ext::shared_ptr< Merton76Process > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess1D >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess > * SWIGSTDCALL CSharp_QuantLib_StochasticProcessArray_SWIGSmartPtrUpcast(ext::shared_ptr< StochasticProcessArray > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess1D > * SWIGSTDCALL CSharp_QuantLib_GeometricBrownianMotionProcess_SWIGSmartPtrUpcast(ext::shared_ptr< GeometricBrownianMotionProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess1D >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess1D > * SWIGSTDCALL CSharp_QuantLib_VarianceGammaProcess_SWIGSmartPtrUpcast(ext::shared_ptr< VarianceGammaProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess1D >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess > * SWIGSTDCALL CSharp_QuantLib_HestonProcess_SWIGSmartPtrUpcast(ext::shared_ptr< HestonProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< HestonProcess > * SWIGSTDCALL CSharp_QuantLib_BatesProcess_SWIGSmartPtrUpcast(ext::shared_ptr< BatesProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< HestonProcess >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess1D > * SWIGSTDCALL CSharp_QuantLib_HullWhiteProcess_SWIGSmartPtrUpcast(ext::shared_ptr< HullWhiteProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess1D >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess1D > * SWIGSTDCALL CSharp_QuantLib_HullWhiteForwardProcess_SWIGSmartPtrUpcast(ext::shared_ptr< HullWhiteForwardProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess1D >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess > * SWIGSTDCALL CSharp_QuantLib_G2Process_SWIGSmartPtrUpcast(ext::shared_ptr< G2Process > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess > * SWIGSTDCALL CSharp_QuantLib_G2ForwardProcess_SWIGSmartPtrUpcast(ext::shared_ptr< G2ForwardProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess1D > * SWIGSTDCALL CSharp_QuantLib_GsrProcess_SWIGSmartPtrUpcast(ext::shared_ptr< GsrProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess1D >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess1D > * SWIGSTDCALL CSharp_QuantLib_OrnsteinUhlenbeckProcess_SWIGSmartPtrUpcast(ext::shared_ptr< OrnsteinUhlenbeckProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess1D >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess1D > * SWIGSTDCALL CSharp_QuantLib_ExtendedOrnsteinUhlenbeckProcess_SWIGSmartPtrUpcast(ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess1D >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess > * SWIGSTDCALL CSharp_QuantLib_ExtOUWithJumpsProcess_SWIGSmartPtrUpcast(ext::shared_ptr< ExtOUWithJumpsProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess > * SWIGSTDCALL CSharp_QuantLib_KlugeExtOUProcess_SWIGSmartPtrUpcast(ext::shared_ptr< KlugeExtOUProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StochasticProcess > * SWIGSTDCALL CSharp_QuantLib_GJRGARCHProcess_SWIGSmartPtrUpcast(ext::shared_ptr< GJRGARCHProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Observable > * SWIGSTDCALL CSharp_QuantLib_LazyObject_SWIGSmartPtrUpcast(ext::shared_ptr< LazyObject > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Observable >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Observable > * SWIGSTDCALL CSharp_QuantLib_PricingEngine_SWIGSmartPtrUpcast(ext::shared_ptr< PricingEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Observable >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< LazyObject > * SWIGSTDCALL CSharp_QuantLib_Instrument_SWIGSmartPtrUpcast(ext::shared_ptr< Instrument > *jarg1) {
    return jarg1 ? new ext::shared_ptr< LazyObject >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_Stock_SWIGSmartPtrUpcast(ext::shared_ptr< Stock > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Instrument >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_CompositeInstrument_SWIGSmartPtrUpcast(ext::shared_ptr< CompositeInstrument > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Instrument >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Observable > * SWIGSTDCALL CSharp_QuantLib_CalibratedModel_SWIGSmartPtrUpcast(ext::shared_ptr< CalibratedModel > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Observable >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Observable > * SWIGSTDCALL CSharp_QuantLib_TermStructureConsistentModel_SWIGSmartPtrUpcast(ext::shared_ptr< TermStructureConsistentModel > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Observable >(*jarg1) : 0;
}

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 ext::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_Option_SWIGSmartPtrUpcast(ext::shared_ptr< Option > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Instrument >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Payoff > * SWIGSTDCALL CSharp_QuantLib_TypePayoff_SWIGSmartPtrUpcast(ext::shared_ptr< TypePayoff > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Payoff >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< TypePayoff > * SWIGSTDCALL CSharp_QuantLib_FloatingTypePayoff_SWIGSmartPtrUpcast(ext::shared_ptr< FloatingTypePayoff > *jarg1) {
    return jarg1 ? new ext::shared_ptr< TypePayoff >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< TypePayoff > * SWIGSTDCALL CSharp_QuantLib_StrikedTypePayoff_SWIGSmartPtrUpcast(ext::shared_ptr< StrikedTypePayoff > *jarg1) {
    return jarg1 ? new ext::shared_ptr< TypePayoff >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Quote > * SWIGSTDCALL CSharp_QuantLib_DeltaVolQuote_SWIGSmartPtrUpcast(ext::shared_ptr< DeltaVolQuote > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Quote >(*jarg1) : 0;
}

SWIGEXPORT Handle< DeltaVolQuote > * SWIGSTDCALL CSharp_QuantLib_RelinkableDeltaVolQuoteHandle_SWIGUpcast(RelinkableHandle< DeltaVolQuote > *jarg1) {
    return (Handle< DeltaVolQuote > *)jarg1;
}

SWIGEXPORT ext::shared_ptr< Option > * SWIGSTDCALL CSharp_QuantLib_OneAssetOption_SWIGSmartPtrUpcast(ext::shared_ptr< OneAssetOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Option >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OneAssetOption > * SWIGSTDCALL CSharp_QuantLib_VanillaOption_SWIGSmartPtrUpcast(ext::shared_ptr< VanillaOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< VanillaOption > * SWIGSTDCALL CSharp_QuantLib_EuropeanOption_SWIGSmartPtrUpcast(ext::shared_ptr< EuropeanOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< VanillaOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OneAssetOption > * SWIGSTDCALL CSharp_QuantLib_ForwardVanillaOption_SWIGSmartPtrUpcast(ext::shared_ptr< ForwardVanillaOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OneAssetOption > * SWIGSTDCALL CSharp_QuantLib_QuantoVanillaOption_SWIGSmartPtrUpcast(ext::shared_ptr< QuantoVanillaOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ForwardVanillaOption > * SWIGSTDCALL CSharp_QuantLib_QuantoForwardVanillaOption_SWIGSmartPtrUpcast(ext::shared_ptr< QuantoForwardVanillaOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ForwardVanillaOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Option > * SWIGSTDCALL CSharp_QuantLib_MultiAssetOption_SWIGSmartPtrUpcast(ext::shared_ptr< MultiAssetOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Option >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticEuropeanEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticEuropeanEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CalibratedModel > * SWIGSTDCALL CSharp_QuantLib_HestonModel_SWIGSmartPtrUpcast(ext::shared_ptr< HestonModel > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CalibratedModel >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CalibratedModel > * SWIGSTDCALL CSharp_QuantLib_PiecewiseTimeDependentHestonModel_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseTimeDependentHestonModel > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CalibratedModel >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticHestonEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_COSHestonEngine_SWIGSmartPtrUpcast(ext::shared_ptr< COSHestonEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_ExponentialFittingHestonEngine_SWIGSmartPtrUpcast(ext::shared_ptr< ExponentialFittingHestonEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticPTDHestonEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticPTDHestonEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< HestonModel > * SWIGSTDCALL CSharp_QuantLib_BatesModel_SWIGSmartPtrUpcast(ext::shared_ptr< BatesModel > *jarg1) {
    return jarg1 ? new ext::shared_ptr< HestonModel >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BatesEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BatesEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_IntegralEngine_SWIGSmartPtrUpcast(ext::shared_ptr< IntegralEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialCRRVanillaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialVanillaEngine< CoxRossRubinstein > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialJRVanillaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialVanillaEngine< JarrowRudd > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialEQPVanillaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialVanillaEngine< AdditiveEQPBinomialTree > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialTrigeorgisVanillaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialVanillaEngine< Trigeorgis > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialTianVanillaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialVanillaEngine< Tian > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialLRVanillaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialVanillaEngine< LeisenReimer > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialJ4VanillaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialVanillaEngine< Joshi4 > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPREuropeanEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCEuropeanEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDEuropeanEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCEuropeanEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPRAmericanEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCAmericanEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDAmericanEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCAmericanEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPREuropeanHestonEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCEuropeanHestonEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDEuropeanHestonEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCEuropeanHestonEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPRDigitalEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCDigitalEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDDigitalEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCDigitalEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BaroneAdesiWhaleyApproximationEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BaroneAdesiWhaleyApproximationEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BjerksundStenslandApproximationEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BjerksundStenslandApproximationEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_JuQuadraticApproximationEngine_SWIGSmartPtrUpcast(ext::shared_ptr< JuQuadraticApproximationEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticDigitalAmericanEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticDigitalAmericanEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticDigitalAmericanKOEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticDigitalAmericanKOEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OneAssetOption > * SWIGSTDCALL CSharp_QuantLib_DividendVanillaOption_SWIGSmartPtrUpcast(ext::shared_ptr< DividendVanillaOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticDividendEuropeanEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticDividendEuropeanEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_QdPlusAmericanEngine_SWIGSmartPtrUpcast(ext::shared_ptr< QdPlusAmericanEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< QdFpIterationScheme > * SWIGSTDCALL CSharp_QuantLib_QdFpLegendreScheme_SWIGSmartPtrUpcast(ext::shared_ptr< QdFpLegendreScheme > *jarg1) {
    return jarg1 ? new ext::shared_ptr< QdFpIterationScheme >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< QdFpLegendreScheme > * SWIGSTDCALL CSharp_QuantLib_QdFpLegendreTanhSinhScheme_SWIGSmartPtrUpcast(ext::shared_ptr< QdFpLegendreTanhSinhScheme > *jarg1) {
    return jarg1 ? new ext::shared_ptr< QdFpLegendreScheme >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< QdFpIterationScheme > * SWIGSTDCALL CSharp_QuantLib_QdFpTanhSinhIterationScheme_SWIGSmartPtrUpcast(ext::shared_ptr< QdFpTanhSinhIterationScheme > *jarg1) {
    return jarg1 ? new ext::shared_ptr< QdFpIterationScheme >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_QdFpAmericanEngine_SWIGSmartPtrUpcast(ext::shared_ptr< QdFpAmericanEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdBlackScholesVanillaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdBlackScholesVanillaEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdBlackScholesShoutEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdBlackScholesShoutEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdOrnsteinUhlenbeckVanillaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdOrnsteinUhlenbeckVanillaEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdBatesVanillaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdBatesVanillaEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdHestonVanillaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdHestonVanillaEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticCEVEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticCEVEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdCEVVanillaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdCEVVanillaEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdSabrVanillaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdSabrVanillaEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdHestonHullWhiteVanillaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdHestonHullWhiteVanillaEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonHullWhiteEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticHestonHullWhiteEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticH1HWEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticH1HWEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_ForwardEuropeanEngine_SWIGSmartPtrUpcast(ext::shared_ptr< ForwardEuropeanEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_QuantoEuropeanEngine_SWIGSmartPtrUpcast(ext::shared_ptr< QuantoEuropeanEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_QuantoForwardEuropeanEngine_SWIGSmartPtrUpcast(ext::shared_ptr< QuantoForwardEuropeanEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticHestonForwardEuropeanEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticHestonForwardEuropeanEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPRForwardEuropeanBSEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCForwardEuropeanBSEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDForwardEuropeanBSEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCForwardEuropeanBSEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPRForwardEuropeanHestonEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCForwardEuropeanHestonEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDForwardEuropeanHestonEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCForwardEuropeanHestonEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_VarianceGammaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< VarianceGammaEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FFTVarianceGammaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FFTVarianceGammaEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CalibratedModel > * SWIGSTDCALL CSharp_QuantLib_GJRGARCHModel_SWIGSmartPtrUpcast(ext::shared_ptr< GJRGARCHModel > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CalibratedModel >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticGJRGARCHEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticGJRGARCHEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPREuropeanGJRGARCHEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCEuropeanGJRGARCHEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDEuropeanGJRGARCHEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCEuropeanGJRGARCHEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< MultiAssetOption > * SWIGSTDCALL CSharp_QuantLib_MargrabeOption_SWIGSmartPtrUpcast(ext::shared_ptr< MargrabeOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< MultiAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticEuropeanMargrabeEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticEuropeanMargrabeEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticAmericanMargrabeEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticAmericanMargrabeEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OneAssetOption > * SWIGSTDCALL CSharp_QuantLib_CompoundOption_SWIGSmartPtrUpcast(ext::shared_ptr< CompoundOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticCompoundOptionEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticCompoundOptionEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OneAssetOption > * SWIGSTDCALL CSharp_QuantLib_SimpleChooserOption_SWIGSmartPtrUpcast(ext::shared_ptr< SimpleChooserOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticSimpleChooserEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticSimpleChooserEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OneAssetOption > * SWIGSTDCALL CSharp_QuantLib_ComplexChooserOption_SWIGSmartPtrUpcast(ext::shared_ptr< ComplexChooserOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticComplexChooserEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticComplexChooserEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OneAssetOption > * SWIGSTDCALL CSharp_QuantLib_ContinuousAveragingAsianOption_SWIGSmartPtrUpcast(ext::shared_ptr< ContinuousAveragingAsianOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OneAssetOption > * SWIGSTDCALL CSharp_QuantLib_DiscreteAveragingAsianOption_SWIGSmartPtrUpcast(ext::shared_ptr< DiscreteAveragingAsianOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticContinuousGeometricAveragePriceAsianEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticContinuousGeometricAveragePriceAsianEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticContinuousGeometricAveragePriceAsianHestonEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticContinuousGeometricAveragePriceAsianHestonEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticDiscreteGeometricAveragePriceAsianEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticDiscreteGeometricAveragePriceAsianEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticDiscreteGeometricAveragePriceAsianHestonEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticDiscreteGeometricAverageStrikeAsianEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticDiscreteGeometricAverageStrikeAsianEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPRDiscreteArithmeticAPEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCDiscreteArithmeticAPEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDDiscreteArithmeticAPEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCDiscreteArithmeticAPEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPRDiscreteArithmeticAPHestonEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCDiscreteArithmeticAPHestonEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDDiscreteArithmeticAPHestonEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPRDiscreteArithmeticASEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCDiscreteArithmeticASEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDDiscreteArithmeticASEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCDiscreteArithmeticASEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPRDiscreteGeometricAPEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCDiscreteGeometricAPEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDDiscreteGeometricAPEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCDiscreteGeometricAPEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPRDiscreteGeometricAPHestonEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCDiscreteGeometricAPHestonEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDDiscreteGeometricAPHestonEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_ContinuousArithmeticAsianLevyEngine_SWIGSmartPtrUpcast(ext::shared_ptr< ContinuousArithmeticAsianLevyEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdBlackScholesAsianEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdBlackScholesAsianEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_TurnbullWakemanAsianEngine_SWIGSmartPtrUpcast(ext::shared_ptr< TurnbullWakemanAsianEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OneAssetOption > * SWIGSTDCALL CSharp_QuantLib_BarrierOption_SWIGSmartPtrUpcast(ext::shared_ptr< BarrierOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BarrierOption > * SWIGSTDCALL CSharp_QuantLib_QuantoBarrierOption_SWIGSmartPtrUpcast(ext::shared_ptr< QuantoBarrierOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BarrierOption >(*jarg1) : 0;
}

SWIGEXPORT Barrier * SWIGSTDCALL CSharp_QuantLib_PartialBarrier_SWIGUpcast(PartialBarrier *jarg1) {
    return (Barrier *)jarg1;
}

SWIGEXPORT ext::shared_ptr< OneAssetOption > * SWIGSTDCALL CSharp_QuantLib_PartialTimeBarrierOption_SWIGSmartPtrUpcast(ext::shared_ptr< PartialTimeBarrierOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticPartialTimeBarrierOptionEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticPartialTimeBarrierOptionEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BarrierOption > * SWIGSTDCALL CSharp_QuantLib_DividendBarrierOption_SWIGSmartPtrUpcast(ext::shared_ptr< DividendBarrierOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BarrierOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticBarrierEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPRBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCBarrierEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCBarrierEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_QuantoBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< QuantoBarrierEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdBlackScholesBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdBlackScholesBarrierEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdBlackScholesRebateEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdBlackScholesRebateEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdHestonBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdHestonBarrierEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdHestonRebateEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdHestonRebateEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticBinaryBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticBinaryBarrierEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialCRRBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialJRBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialEQPBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialTrigeorgisBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialTianBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialLRBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialJ4BarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_VannaVolgaBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< VannaVolgaBarrierEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OneAssetOption > * SWIGSTDCALL CSharp_QuantLib_DoubleBarrierOption_SWIGSmartPtrUpcast(ext::shared_ptr< DoubleBarrierOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< DoubleBarrierOption > * SWIGSTDCALL CSharp_QuantLib_QuantoDoubleBarrierOption_SWIGSmartPtrUpcast(ext::shared_ptr< QuantoDoubleBarrierOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< DoubleBarrierOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticDoubleBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticDoubleBarrierEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdHestonDoubleBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdHestonDoubleBarrierEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_SuoWangDoubleBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< SuoWangDoubleBarrierEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_VannaVolgaIKDoubleBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_VannaVolgaWODoubleBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticDoubleBarrierBinaryEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticDoubleBarrierBinaryEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialCRRDoubleBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialJRDoubleBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialEQPDoubleBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialTrigeorgisDoubleBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialTianDoubleBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialLRDoubleBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialJ4DoubleBarrierEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StrikedTypePayoff > * SWIGSTDCALL CSharp_QuantLib_PlainVanillaPayoff_SWIGSmartPtrUpcast(ext::shared_ptr< PlainVanillaPayoff > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StrikedTypePayoff >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StrikedTypePayoff > * SWIGSTDCALL CSharp_QuantLib_PercentageStrikePayoff_SWIGSmartPtrUpcast(ext::shared_ptr< PercentageStrikePayoff > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StrikedTypePayoff >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StrikedTypePayoff > * SWIGSTDCALL CSharp_QuantLib_CashOrNothingPayoff_SWIGSmartPtrUpcast(ext::shared_ptr< CashOrNothingPayoff > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StrikedTypePayoff >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StrikedTypePayoff > * SWIGSTDCALL CSharp_QuantLib_AssetOrNothingPayoff_SWIGSmartPtrUpcast(ext::shared_ptr< AssetOrNothingPayoff > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StrikedTypePayoff >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StrikedTypePayoff > * SWIGSTDCALL CSharp_QuantLib_SuperSharePayoff_SWIGSmartPtrUpcast(ext::shared_ptr< SuperSharePayoff > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StrikedTypePayoff >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StrikedTypePayoff > * SWIGSTDCALL CSharp_QuantLib_GapPayoff_SWIGSmartPtrUpcast(ext::shared_ptr< GapPayoff > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StrikedTypePayoff >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StrikedTypePayoff > * SWIGSTDCALL CSharp_QuantLib_VanillaForwardPayoff_SWIGSmartPtrUpcast(ext::shared_ptr< VanillaForwardPayoff > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StrikedTypePayoff >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Payoff > * SWIGSTDCALL CSharp_QuantLib_BasketPayoff_SWIGSmartPtrUpcast(ext::shared_ptr< BasketPayoff > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Payoff >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BasketPayoff > * SWIGSTDCALL CSharp_QuantLib_MinBasketPayoff_SWIGSmartPtrUpcast(ext::shared_ptr< MinBasketPayoff > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BasketPayoff >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BasketPayoff > * SWIGSTDCALL CSharp_QuantLib_MaxBasketPayoff_SWIGSmartPtrUpcast(ext::shared_ptr< MaxBasketPayoff > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BasketPayoff >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BasketPayoff > * SWIGSTDCALL CSharp_QuantLib_AverageBasketPayoff_SWIGSmartPtrUpcast(ext::shared_ptr< AverageBasketPayoff > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BasketPayoff >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BasketPayoff > * SWIGSTDCALL CSharp_QuantLib_SpreadBasketPayoff_SWIGSmartPtrUpcast(ext::shared_ptr< SpreadBasketPayoff > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BasketPayoff >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< MultiAssetOption > * SWIGSTDCALL CSharp_QuantLib_BasketOption_SWIGSmartPtrUpcast(ext::shared_ptr< BasketOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< MultiAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPREuropeanBasketEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCEuropeanBasketEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDEuropeanBasketEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCEuropeanBasketEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPRAmericanBasketEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCAmericanBasketEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDAmericanBasketEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCAmericanBasketEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_StulzEngine_SWIGSmartPtrUpcast(ext::shared_ptr< StulzEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_KirkEngine_SWIGSmartPtrUpcast(ext::shared_ptr< KirkEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_Fd2dBlackScholesVanillaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< Fd2dBlackScholesVanillaEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< MultiAssetOption > * SWIGSTDCALL CSharp_QuantLib_EverestOption_SWIGSmartPtrUpcast(ext::shared_ptr< EverestOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< MultiAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPREverestEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCEverestEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDEverestEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCEverestEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< MultiAssetOption > * SWIGSTDCALL CSharp_QuantLib_HimalayaOption_SWIGSmartPtrUpcast(ext::shared_ptr< HimalayaOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< MultiAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPRHimalayaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCHimalayaEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDHimalayaEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCHimalayaEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_Swap_SWIGSmartPtrUpcast(ext::shared_ptr< Swap > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Instrument >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Swap > * SWIGSTDCALL CSharp_QuantLib_VanillaSwap_SWIGSmartPtrUpcast(ext::shared_ptr< VanillaSwap > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Swap >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Swap > * SWIGSTDCALL CSharp_QuantLib_NonstandardSwap_SWIGSmartPtrUpcast(ext::shared_ptr< NonstandardSwap > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Swap >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_DiscountingSwapEngine_SWIGSmartPtrUpcast(ext::shared_ptr< DiscountingSwapEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Swap > * SWIGSTDCALL CSharp_QuantLib_AssetSwap_SWIGSmartPtrUpcast(ext::shared_ptr< AssetSwap > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Swap >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Swap > * SWIGSTDCALL CSharp_QuantLib_FloatFloatSwap_SWIGSmartPtrUpcast(ext::shared_ptr< FloatFloatSwap > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Swap >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Swap > * SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwap_SWIGSmartPtrUpcast(ext::shared_ptr< OvernightIndexedSwap > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Swap >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< SwapIndex > * SWIGSTDCALL CSharp_QuantLib_OvernightIndexedSwapIndex_SWIGSmartPtrUpcast(ext::shared_ptr< OvernightIndexedSwapIndex > *jarg1) {
    return jarg1 ? new ext::shared_ptr< SwapIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Swap > * SWIGSTDCALL CSharp_QuantLib_ZeroCouponSwap_SWIGSmartPtrUpcast(ext::shared_ptr< ZeroCouponSwap > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Swap >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Swap > * SWIGSTDCALL CSharp_QuantLib_EquityTotalReturnSwap_SWIGSmartPtrUpcast(ext::shared_ptr< EquityTotalReturnSwap > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Swap >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Swap > * SWIGSTDCALL CSharp_QuantLib_ArithmeticAverageOIS_SWIGSmartPtrUpcast(ext::shared_ptr< ArithmeticAverageOIS > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Swap >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Seasonality > * SWIGSTDCALL CSharp_QuantLib_MultiplicativePriceSeasonality_SWIGSmartPtrUpcast(ext::shared_ptr< MultiplicativePriceSeasonality > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Seasonality >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Seasonality > * SWIGSTDCALL CSharp_QuantLib_KerkhofSeasonality_SWIGSmartPtrUpcast(ext::shared_ptr< KerkhofSeasonality > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Seasonality >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< TermStructure > * SWIGSTDCALL CSharp_QuantLib_InflationTermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< InflationTermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< TermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< InflationTermStructure > * SWIGSTDCALL CSharp_QuantLib_YoYInflationTermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< YoYInflationTermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< InflationTermStructure >(*jarg1) : 0;
}

SWIGEXPORT Handle< YoYInflationTermStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableYoYInflationTermStructureHandle_SWIGUpcast(RelinkableHandle< YoYInflationTermStructure > *jarg1) {
    return (Handle< YoYInflationTermStructure > *)jarg1;
}

SWIGEXPORT ext::shared_ptr< InflationTermStructure > * SWIGSTDCALL CSharp_QuantLib_ZeroInflationTermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< ZeroInflationTermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< InflationTermStructure >(*jarg1) : 0;
}

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 ext::shared_ptr< Index > * SWIGSTDCALL CSharp_QuantLib_InflationIndex_SWIGSmartPtrUpcast(ext::shared_ptr< InflationIndex > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Index >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< InflationIndex > * SWIGSTDCALL CSharp_QuantLib_ZeroInflationIndex_SWIGSmartPtrUpcast(ext::shared_ptr< ZeroInflationIndex > *jarg1) {
    return jarg1 ? new ext::shared_ptr< InflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< InflationIndex > * SWIGSTDCALL CSharp_QuantLib_YoYInflationIndex_SWIGSmartPtrUpcast(ext::shared_ptr< YoYInflationIndex > *jarg1) {
    return jarg1 ? new ext::shared_ptr< InflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ZeroInflationIndex > * SWIGSTDCALL CSharp_QuantLib_EUHICP_SWIGSmartPtrUpcast(ext::shared_ptr< EUHICP > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ZeroInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ZeroInflationIndex > * SWIGSTDCALL CSharp_QuantLib_EUHICPXT_SWIGSmartPtrUpcast(ext::shared_ptr< EUHICPXT > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ZeroInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ZeroInflationIndex > * SWIGSTDCALL CSharp_QuantLib_FRHICP_SWIGSmartPtrUpcast(ext::shared_ptr< FRHICP > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ZeroInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ZeroInflationIndex > * SWIGSTDCALL CSharp_QuantLib_UKRPI_SWIGSmartPtrUpcast(ext::shared_ptr< UKRPI > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ZeroInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ZeroInflationIndex > * SWIGSTDCALL CSharp_QuantLib_USCPI_SWIGSmartPtrUpcast(ext::shared_ptr< USCPI > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ZeroInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ZeroInflationIndex > * SWIGSTDCALL CSharp_QuantLib_ZACPI_SWIGSmartPtrUpcast(ext::shared_ptr< ZACPI > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ZeroInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ZeroInflationIndex > * SWIGSTDCALL CSharp_QuantLib_UKHICP_SWIGSmartPtrUpcast(ext::shared_ptr< UKHICP > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ZeroInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationIndex > * SWIGSTDCALL CSharp_QuantLib_YYEUHICP_SWIGSmartPtrUpcast(ext::shared_ptr< YYEUHICP > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationIndex > * SWIGSTDCALL CSharp_QuantLib_YYEUHICPXT_SWIGSmartPtrUpcast(ext::shared_ptr< YYEUHICPXT > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationIndex > * SWIGSTDCALL CSharp_QuantLib_YYEUHICPr_SWIGSmartPtrUpcast(ext::shared_ptr< YYEUHICPr > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationIndex > * SWIGSTDCALL CSharp_QuantLib_YYFRHICP_SWIGSmartPtrUpcast(ext::shared_ptr< YYFRHICP > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationIndex > * SWIGSTDCALL CSharp_QuantLib_YYFRHICPr_SWIGSmartPtrUpcast(ext::shared_ptr< YYFRHICPr > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationIndex > * SWIGSTDCALL CSharp_QuantLib_YYUKRPI_SWIGSmartPtrUpcast(ext::shared_ptr< YYUKRPI > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationIndex > * SWIGSTDCALL CSharp_QuantLib_YYUKRPIr_SWIGSmartPtrUpcast(ext::shared_ptr< YYUKRPIr > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationIndex > * SWIGSTDCALL CSharp_QuantLib_YYUSCPI_SWIGSmartPtrUpcast(ext::shared_ptr< YYUSCPI > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationIndex > * SWIGSTDCALL CSharp_QuantLib_YYUSCPIr_SWIGSmartPtrUpcast(ext::shared_ptr< YYUSCPIr > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationIndex > * SWIGSTDCALL CSharp_QuantLib_YYZACPI_SWIGSmartPtrUpcast(ext::shared_ptr< YYZACPI > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationIndex > * SWIGSTDCALL CSharp_QuantLib_YYZACPIr_SWIGSmartPtrUpcast(ext::shared_ptr< YYZACPIr > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ZeroInflationIndex > * SWIGSTDCALL CSharp_QuantLib_AUCPI_SWIGSmartPtrUpcast(ext::shared_ptr< AUCPI > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ZeroInflationIndex >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Coupon > * SWIGSTDCALL CSharp_QuantLib_InflationCoupon_SWIGSmartPtrUpcast(ext::shared_ptr< InflationCoupon > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Coupon >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< InflationCoupon > * SWIGSTDCALL CSharp_QuantLib_CPICoupon_SWIGSmartPtrUpcast(ext::shared_ptr< CPICoupon > *jarg1) {
    return jarg1 ? new ext::shared_ptr< InflationCoupon >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< IndexedCashFlow > * SWIGSTDCALL CSharp_QuantLib_CPICashFlow_SWIGSmartPtrUpcast(ext::shared_ptr< CPICashFlow > *jarg1) {
    return jarg1 ? new ext::shared_ptr< IndexedCashFlow >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CashFlow > * SWIGSTDCALL CSharp_QuantLib_ZeroInflationCashFlow_SWIGSmartPtrUpcast(ext::shared_ptr< ZeroInflationCashFlow > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CashFlow >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Observable > * SWIGSTDCALL CSharp_QuantLib_ZeroHelper_SWIGSmartPtrUpcast(ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Observable >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Observable > * SWIGSTDCALL CSharp_QuantLib_YoYHelper_SWIGSmartPtrUpcast(ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Observable >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Observable > * SWIGSTDCALL CSharp_QuantLib_YoYOptionHelper_SWIGSmartPtrUpcast(ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Observable >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > * SWIGSTDCALL CSharp_QuantLib_ZeroCouponInflationSwapHelper_SWIGSmartPtrUpcast(ext::shared_ptr< ZeroCouponInflationSwapHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > * SWIGSTDCALL CSharp_QuantLib_YearOnYearInflationSwapHelper_SWIGSmartPtrUpcast(ext::shared_ptr< YearOnYearInflationSwapHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ZeroInflationTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseZeroInflation_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ZeroInflationTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseYoYInflation_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< InflationCoupon > * SWIGSTDCALL CSharp_QuantLib_YoYInflationCoupon_SWIGSmartPtrUpcast(ext::shared_ptr< YoYInflationCoupon > *jarg1) {
    return jarg1 ? new ext::shared_ptr< InflationCoupon >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationCoupon > * SWIGSTDCALL CSharp_QuantLib_CappedFlooredYoYInflationCoupon_SWIGSmartPtrUpcast(ext::shared_ptr< CappedFlooredYoYInflationCoupon > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationCoupon >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationCouponPricer > * SWIGSTDCALL CSharp_QuantLib_BlackYoYInflationCouponPricer_SWIGSmartPtrUpcast(ext::shared_ptr< BlackYoYInflationCouponPricer > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationCouponPricer >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationCouponPricer > * SWIGSTDCALL CSharp_QuantLib_UnitDisplacedBlackYoYInflationCouponPricer_SWIGSmartPtrUpcast(ext::shared_ptr< UnitDisplacedBlackYoYInflationCouponPricer > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationCouponPricer >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationCouponPricer > * SWIGSTDCALL CSharp_QuantLib_BachelierYoYInflationCouponPricer_SWIGSmartPtrUpcast(ext::shared_ptr< BachelierYoYInflationCouponPricer > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationCouponPricer >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Swap > * SWIGSTDCALL CSharp_QuantLib_ZeroCouponInflationSwap_SWIGSmartPtrUpcast(ext::shared_ptr< ZeroCouponInflationSwap > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Swap >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Swap > * SWIGSTDCALL CSharp_QuantLib_YearOnYearInflationSwap_SWIGSmartPtrUpcast(ext::shared_ptr< YearOnYearInflationSwap > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Swap >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Swap > * SWIGSTDCALL CSharp_QuantLib_CPISwap_SWIGSmartPtrUpcast(ext::shared_ptr< CPISwap > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Swap >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_YoYInflationCapFloor_SWIGSmartPtrUpcast(ext::shared_ptr< YoYInflationCapFloor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Instrument >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationCapFloor > * SWIGSTDCALL CSharp_QuantLib_YoYInflationCap_SWIGSmartPtrUpcast(ext::shared_ptr< YoYInflationCap > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationCapFloor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationCapFloor > * SWIGSTDCALL CSharp_QuantLib_YoYInflationFloor_SWIGSmartPtrUpcast(ext::shared_ptr< YoYInflationFloor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationCapFloor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationCapFloor > * SWIGSTDCALL CSharp_QuantLib_YoYInflationCollar_SWIGSmartPtrUpcast(ext::shared_ptr< YoYInflationCollar > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationCapFloor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ZeroInflationTermStructure > * SWIGSTDCALL CSharp_QuantLib_ZeroInflationCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ZeroInflationTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYInflationTermStructure > * SWIGSTDCALL CSharp_QuantLib_YoYInflationCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYInflationTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< InflationTermStructure > * SWIGSTDCALL CSharp_QuantLib_YoYCapFloorTermPriceSurface_SWIGSmartPtrUpcast(ext::shared_ptr< YoYCapFloorTermPriceSurface > *jarg1) {
    return jarg1 ? new ext::shared_ptr< InflationTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYCapFloorTermPriceSurface > * SWIGSTDCALL CSharp_QuantLib_YoYInflationCapFloorTermPriceSurface_SWIGSmartPtrUpcast(ext::shared_ptr< YoYInflationCapFloorTermPriceSurface > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYCapFloorTermPriceSurface >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_YoYInflationBlackCapFloorEngine_SWIGSmartPtrUpcast(ext::shared_ptr< YoYInflationBlackCapFloorEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_YoYInflationUnitDisplacedBlackCapFloorEngine_SWIGSmartPtrUpcast(ext::shared_ptr< YoYInflationUnitDisplacedBlackCapFloorEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_YoYInflationBachelierCapFloorEngine_SWIGSmartPtrUpcast(ext::shared_ptr< YoYInflationBachelierCapFloorEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > * SWIGSTDCALL CSharp_QuantLib_YoYOptionletHelper_SWIGSmartPtrUpcast(ext::shared_ptr< YoYOptionletHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYOptionletStripper > * SWIGSTDCALL CSharp_QuantLib_InterpolatedYoYInflationOptionletStripper_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedYoYOptionletStripper< Linear > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYOptionletStripper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYOptionletVolatilitySurface > * SWIGSTDCALL CSharp_QuantLib_InterpolatedYoYInflationOptionletVolatilityCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedYoYOptionletVolatilityCurve< Linear > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYOptionletVolatilitySurface >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YoYOptionletVolatilitySurface > * SWIGSTDCALL CSharp_QuantLib_KInterpolatedYoYInflationOptionletVolatilitySurface_SWIGSmartPtrUpcast(ext::shared_ptr< KInterpolatedYoYOptionletVolatilitySurface< Linear > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YoYOptionletVolatilitySurface >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CalibratedModel > * SWIGSTDCALL CSharp_QuantLib_ShortRateModel_SWIGSmartPtrUpcast(ext::shared_ptr< ShortRateModel > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CalibratedModel >(*jarg1) : 0;
}

SWIGEXPORT Handle< ShortRateModel > * SWIGSTDCALL CSharp_QuantLib_RelinkableShortRateModelHandle_SWIGUpcast(RelinkableHandle< ShortRateModel > *jarg1) {
    return (Handle< ShortRateModel > *)jarg1;
}

SWIGEXPORT ext::shared_ptr< ShortRateModel > * SWIGSTDCALL CSharp_QuantLib_OneFactorAffineModel_SWIGSmartPtrUpcast(ext::shared_ptr< OneFactorAffineModel > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ShortRateModel >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OneFactorAffineModel > * SWIGSTDCALL CSharp_QuantLib_Vasicek_SWIGSmartPtrUpcast(ext::shared_ptr< Vasicek > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneFactorAffineModel >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Vasicek > * SWIGSTDCALL CSharp_QuantLib_HullWhite_SWIGSmartPtrUpcast(ext::shared_ptr< HullWhite > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Vasicek >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ShortRateModel > * SWIGSTDCALL CSharp_QuantLib_BlackKarasinski_SWIGSmartPtrUpcast(ext::shared_ptr< BlackKarasinski > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ShortRateModel >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ShortRateModel > * SWIGSTDCALL CSharp_QuantLib_CoxIngersollRoss_SWIGSmartPtrUpcast(ext::shared_ptr< CoxIngersollRoss > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ShortRateModel >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ShortRateModel > * SWIGSTDCALL CSharp_QuantLib_ExtendedCoxIngersollRoss_SWIGSmartPtrUpcast(ext::shared_ptr< ExtendedCoxIngersollRoss > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ShortRateModel >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ShortRateModel > * SWIGSTDCALL CSharp_QuantLib_G2_SWIGSmartPtrUpcast(ext::shared_ptr< G2 > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ShortRateModel >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_JamshidianSwaptionEngine_SWIGSmartPtrUpcast(ext::shared_ptr< JamshidianSwaptionEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_TreeSwaptionEngine_SWIGSmartPtrUpcast(ext::shared_ptr< TreeSwaptionEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticCapFloorEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticCapFloorEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_TreeCapFloorEngine_SWIGSmartPtrUpcast(ext::shared_ptr< TreeCapFloorEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_G2SwaptionEngine_SWIGSmartPtrUpcast(ext::shared_ptr< G2SwaptionEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdG2SwaptionEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdG2SwaptionEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdHullWhiteSwaptionEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdHullWhiteSwaptionEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticBSMHullWhiteEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticBSMHullWhiteEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_Bond_SWIGSmartPtrUpcast(ext::shared_ptr< Bond > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Instrument >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bond > * SWIGSTDCALL CSharp_QuantLib_ZeroCouponBond_SWIGSmartPtrUpcast(ext::shared_ptr< ZeroCouponBond > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bond >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bond > * SWIGSTDCALL CSharp_QuantLib_FixedRateBond_SWIGSmartPtrUpcast(ext::shared_ptr< FixedRateBond > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bond >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bond > * SWIGSTDCALL CSharp_QuantLib_AmortizingFixedRateBond_SWIGSmartPtrUpcast(ext::shared_ptr< AmortizingFixedRateBond > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bond >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bond > * SWIGSTDCALL CSharp_QuantLib_AmortizingFloatingRateBond_SWIGSmartPtrUpcast(ext::shared_ptr< AmortizingFloatingRateBond > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bond >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bond > * SWIGSTDCALL CSharp_QuantLib_FloatingRateBond_SWIGSmartPtrUpcast(ext::shared_ptr< FloatingRateBond > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bond >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bond > * SWIGSTDCALL CSharp_QuantLib_CmsRateBond_SWIGSmartPtrUpcast(ext::shared_ptr< CmsRateBond > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bond >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bond > * SWIGSTDCALL CSharp_QuantLib_AmortizingCmsRateBond_SWIGSmartPtrUpcast(ext::shared_ptr< AmortizingCmsRateBond > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bond >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_DiscountingBondEngine_SWIGSmartPtrUpcast(ext::shared_ptr< DiscountingBondEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Callability > * SWIGSTDCALL CSharp_QuantLib_SoftCallability_SWIGSmartPtrUpcast(ext::shared_ptr< SoftCallability > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Callability >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bond > * SWIGSTDCALL CSharp_QuantLib_CallableBond_SWIGSmartPtrUpcast(ext::shared_ptr< CallableBond > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bond >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CallableBond > * SWIGSTDCALL CSharp_QuantLib_CallableFixedRateBond_SWIGSmartPtrUpcast(ext::shared_ptr< CallableFixedRateBond > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CallableBond >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CallableBond > * SWIGSTDCALL CSharp_QuantLib_CallableZeroCouponBond_SWIGSmartPtrUpcast(ext::shared_ptr< CallableZeroCouponBond > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CallableBond >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_TreeCallableFixedRateBondEngine_SWIGSmartPtrUpcast(ext::shared_ptr< TreeCallableFixedRateBondEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BlackCallableFixedRateBondEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BlackCallableFixedRateBondEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bond > * SWIGSTDCALL CSharp_QuantLib_CPIBond_SWIGSmartPtrUpcast(ext::shared_ptr< CPIBond > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bond >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CalibrationHelper > * SWIGSTDCALL CSharp_QuantLib_BlackCalibrationHelper_SWIGSmartPtrUpcast(ext::shared_ptr< BlackCalibrationHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CalibrationHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BlackCalibrationHelper > * SWIGSTDCALL CSharp_QuantLib_SwaptionHelper_SWIGSmartPtrUpcast(ext::shared_ptr< SwaptionHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BlackCalibrationHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BlackCalibrationHelper > * SWIGSTDCALL CSharp_QuantLib_CapHelper_SWIGSmartPtrUpcast(ext::shared_ptr< CapHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BlackCalibrationHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BlackCalibrationHelper > * SWIGSTDCALL CSharp_QuantLib_HestonModelHelper_SWIGSmartPtrUpcast(ext::shared_ptr< HestonModelHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BlackCalibrationHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_CapFloor_SWIGSmartPtrUpcast(ext::shared_ptr< CapFloor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Instrument >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CapFloor > * SWIGSTDCALL CSharp_QuantLib_Cap_SWIGSmartPtrUpcast(ext::shared_ptr< Cap > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CapFloor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CapFloor > * SWIGSTDCALL CSharp_QuantLib_Floor_SWIGSmartPtrUpcast(ext::shared_ptr< Floor > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CapFloor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CapFloor > * SWIGSTDCALL CSharp_QuantLib_Collar_SWIGSmartPtrUpcast(ext::shared_ptr< Collar > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CapFloor >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BlackCapFloorEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BlackCapFloorEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BachelierCapFloorEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BachelierCapFloorEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OneAssetOption > * SWIGSTDCALL CSharp_QuantLib_CliquetOption_SWIGSmartPtrUpcast(ext::shared_ptr< CliquetOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticCliquetEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticCliquetEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticPerformanceEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticPerformanceEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCPRPerformanceEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCPerformanceEngine< PseudoRandom > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MCLDPerformanceEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MCPerformanceEngine< LowDiscrepancy > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bond > * SWIGSTDCALL CSharp_QuantLib_ConvertibleZeroCouponBond_SWIGSmartPtrUpcast(ext::shared_ptr< ConvertibleZeroCouponBond > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bond >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bond > * SWIGSTDCALL CSharp_QuantLib_ConvertibleFixedCouponBond_SWIGSmartPtrUpcast(ext::shared_ptr< ConvertibleFixedCouponBond > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bond >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Bond > * SWIGSTDCALL CSharp_QuantLib_ConvertibleFloatingRateBond_SWIGSmartPtrUpcast(ext::shared_ptr< ConvertibleFloatingRateBond > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Bond >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialCRRConvertibleEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialConvertibleEngine< CoxRossRubinstein > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialJRConvertibleEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialConvertibleEngine< JarrowRudd > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialEQPConvertibleEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialConvertibleEngine< AdditiveEQPBinomialTree > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialTrigeorgisConvertibleEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialConvertibleEngine< Trigeorgis > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialTianConvertibleEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialConvertibleEngine< Tian > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialLRConvertibleEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialConvertibleEngine< LeisenReimer > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BinomialJ4ConvertibleEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BinomialConvertibleEngine< Joshi4 > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_Forward_SWIGSmartPtrUpcast(ext::shared_ptr< Forward > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Instrument >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Forward > * SWIGSTDCALL CSharp_QuantLib_BondForward_SWIGSmartPtrUpcast(ext::shared_ptr< BondForward > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Forward >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BondForward > * SWIGSTDCALL CSharp_QuantLib_FixedRateBondForward_SWIGSmartPtrUpcast(ext::shared_ptr< FixedRateBondForward > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BondForward >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_OvernightIndexFuture_SWIGSmartPtrUpcast(ext::shared_ptr< OvernightIndexFuture > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Instrument >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Observable > * SWIGSTDCALL CSharp_QuantLib_RateHelper_SWIGSmartPtrUpcast(ext::shared_ptr< RateHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Observable >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_DepositRateHelper_SWIGSmartPtrUpcast(ext::shared_ptr< DepositRateHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RateHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_FraRateHelper_SWIGSmartPtrUpcast(ext::shared_ptr< FraRateHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RateHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_FuturesRateHelper_SWIGSmartPtrUpcast(ext::shared_ptr< FuturesRateHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RateHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_SwapRateHelper_SWIGSmartPtrUpcast(ext::shared_ptr< SwapRateHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RateHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_BondHelper_SWIGSmartPtrUpcast(ext::shared_ptr< BondHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RateHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BondHelper > * SWIGSTDCALL CSharp_QuantLib_FixedRateBondHelper_SWIGSmartPtrUpcast(ext::shared_ptr< FixedRateBondHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BondHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_OISRateHelper_SWIGSmartPtrUpcast(ext::shared_ptr< OISRateHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RateHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_DatedOISRateHelper_SWIGSmartPtrUpcast(ext::shared_ptr< DatedOISRateHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RateHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_FxSwapRateHelper_SWIGSmartPtrUpcast(ext::shared_ptr< FxSwapRateHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RateHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_OvernightIndexFutureRateHelper_SWIGSmartPtrUpcast(ext::shared_ptr< OvernightIndexFutureRateHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RateHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OvernightIndexFutureRateHelper > * SWIGSTDCALL CSharp_QuantLib_SofrFutureRateHelper_SWIGSmartPtrUpcast(ext::shared_ptr< SofrFutureRateHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OvernightIndexFutureRateHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_ConstNotionalCrossCurrencyBasisSwapRateHelper_SWIGSmartPtrUpcast(ext::shared_ptr< ConstNotionalCrossCurrencyBasisSwapRateHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RateHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_MtMCrossCurrencyBasisSwapRateHelper_SWIGSmartPtrUpcast(ext::shared_ptr< MtMCrossCurrencyBasisSwapRateHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RateHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_IborIborBasisSwapRateHelper_SWIGSmartPtrUpcast(ext::shared_ptr< IborIborBasisSwapRateHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RateHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_OvernightIborBasisSwapRateHelper_SWIGSmartPtrUpcast(ext::shared_ptr< OvernightIborBasisSwapRateHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RateHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RateHelper > * SWIGSTDCALL CSharp_QuantLib_ArithmeticOISRateHelper_SWIGSmartPtrUpcast(ext::shared_ptr< ArithmeticOISRateHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RateHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseFlatForward_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseFlatForward > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseLogLinearDiscount_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseLogLinearDiscount > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseLinearForward_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseLinearForward > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseLinearZero_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseLinearZero > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseCubicZero_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseCubicZero > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseLogCubicDiscount_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseLogCubicDiscount > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseSplineCubicDiscount_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseSplineCubicDiscount > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseKrugerZero_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseKrugerZero > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseKrugerLogDiscount_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseKrugerLogDiscount > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseConvexMonotoneForward_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseConvexMonotoneForward > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseConvexMonotoneZero_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseConvexMonotoneZero > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseNaturalCubicZero_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseNaturalCubicZero > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseNaturalLogCubicDiscount_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseNaturalLogCubicDiscount > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseLogMixedLinearCubicDiscount_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_GlobalLinearSimpleZeroCurve_SWIGSmartPtrUpcast(ext::shared_ptr< GlobalLinearSimpleZeroCurve > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< TermStructure > * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityTermStructure_SWIGSmartPtrUpcast(ext::shared_ptr< DefaultProbabilityTermStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< TermStructure >(*jarg1) : 0;
}

SWIGEXPORT Handle< DefaultProbabilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableDefaultProbabilityTermStructureHandle_SWIGUpcast(RelinkableHandle< DefaultProbabilityTermStructure > *jarg1) {
    return (Handle< DefaultProbabilityTermStructure > *)jarg1;
}

SWIGEXPORT ext::shared_ptr< DefaultProbabilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_FlatHazardRate_SWIGSmartPtrUpcast(ext::shared_ptr< FlatHazardRate > *jarg1) {
    return jarg1 ? new ext::shared_ptr< DefaultProbabilityTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< DefaultProbabilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_HazardRateCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< DefaultProbabilityTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< DefaultProbabilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_DefaultDensityCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< DefaultProbabilityTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< DefaultProbabilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_SurvivalProbabilityCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< DefaultProbabilityTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Observable > * SWIGSTDCALL CSharp_QuantLib_DefaultProbabilityHelper_SWIGSmartPtrUpcast(ext::shared_ptr< DefaultProbabilityHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Observable >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< DefaultProbabilityHelper > * SWIGSTDCALL CSharp_QuantLib_SpreadCdsHelper_SWIGSmartPtrUpcast(ext::shared_ptr< SpreadCdsHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< DefaultProbabilityHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< DefaultProbabilityHelper > * SWIGSTDCALL CSharp_QuantLib_UpfrontCdsHelper_SWIGSmartPtrUpcast(ext::shared_ptr< UpfrontCdsHelper > *jarg1) {
    return jarg1 ? new ext::shared_ptr< DefaultProbabilityHelper >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< DefaultProbabilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_PiecewiseFlatHazardRate_SWIGSmartPtrUpcast(ext::shared_ptr< PiecewiseFlatHazardRate > *jarg1) {
    return jarg1 ? new ext::shared_ptr< DefaultProbabilityTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_RiskyBondEngine_SWIGSmartPtrUpcast(ext::shared_ptr< RiskyBondEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Claim > * SWIGSTDCALL CSharp_QuantLib_FaceValueClaim_SWIGSmartPtrUpcast(ext::shared_ptr< FaceValueClaim > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Claim >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Claim > * SWIGSTDCALL CSharp_QuantLib_FaceValueAccrualClaim_SWIGSmartPtrUpcast(ext::shared_ptr< FaceValueAccrualClaim > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Claim >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_CreditDefaultSwap_SWIGSmartPtrUpcast(ext::shared_ptr< CreditDefaultSwap > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Instrument >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_MidPointCdsEngine_SWIGSmartPtrUpcast(ext::shared_ptr< MidPointCdsEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_IntegralCdsEngine_SWIGSmartPtrUpcast(ext::shared_ptr< IntegralCdsEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_IsdaCdsEngine_SWIGSmartPtrUpcast(ext::shared_ptr< IsdaCdsEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Option > * SWIGSTDCALL CSharp_QuantLib_CdsOption_SWIGSmartPtrUpcast(ext::shared_ptr< CdsOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Option >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BlackCdsOptionEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BlackCdsOptionEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_DiscountCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_MonotonicLogCubicDiscountCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_NaturalCubicDiscountCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_KrugerLogDiscountCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_NaturalLogCubicDiscountCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_LogMixedLinearCubicDiscountCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Fdm1dMesher > * SWIGSTDCALL CSharp_QuantLib_FdmBlackScholesMesher_SWIGSmartPtrUpcast(ext::shared_ptr< FdmBlackScholesMesher > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Fdm1dMesher >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Fdm1dMesher > * SWIGSTDCALL CSharp_QuantLib_Concentrating1dMesher_SWIGSmartPtrUpcast(ext::shared_ptr< Concentrating1dMesher > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Fdm1dMesher >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Fdm1dMesher > * SWIGSTDCALL CSharp_QuantLib_ExponentialJump1dMesher_SWIGSmartPtrUpcast(ext::shared_ptr< ExponentialJump1dMesher > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Fdm1dMesher >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Fdm1dMesher > * SWIGSTDCALL CSharp_QuantLib_FdmCEV1dMesher_SWIGSmartPtrUpcast(ext::shared_ptr< FdmCEV1dMesher > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Fdm1dMesher >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Fdm1dMesher > * SWIGSTDCALL CSharp_QuantLib_FdmHestonVarianceMesher_SWIGSmartPtrUpcast(ext::shared_ptr< FdmHestonVarianceMesher > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Fdm1dMesher >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Fdm1dMesher > * SWIGSTDCALL CSharp_QuantLib_FdmHestonLocalVolatilityVarianceMesher_SWIGSmartPtrUpcast(ext::shared_ptr< FdmHestonLocalVolatilityVarianceMesher > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Fdm1dMesher >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Fdm1dMesher > * SWIGSTDCALL CSharp_QuantLib_FdmSimpleProcess1dMesher_SWIGSmartPtrUpcast(ext::shared_ptr< FdmSimpleProcess1dMesher > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Fdm1dMesher >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Fdm1dMesher > * SWIGSTDCALL CSharp_QuantLib_Uniform1dMesher_SWIGSmartPtrUpcast(ext::shared_ptr< Uniform1dMesher > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Fdm1dMesher >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Fdm1dMesher > * SWIGSTDCALL CSharp_QuantLib_Predefined1dMesher_SWIGSmartPtrUpcast(ext::shared_ptr< Predefined1dMesher > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Fdm1dMesher >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Fdm1dMesher > * SWIGSTDCALL CSharp_QuantLib_Glued1dMesher_SWIGSmartPtrUpcast(ext::shared_ptr< Glued1dMesher > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Fdm1dMesher >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmMesher > * SWIGSTDCALL CSharp_QuantLib_FdmMesherComposite_SWIGSmartPtrUpcast(ext::shared_ptr< FdmMesherComposite > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmMesher >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOp > * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpComposite_SWIGSmartPtrUpcast(ext::shared_ptr< FdmLinearOpComposite > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOp >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_FdmLinearOpCompositeProxy_SWIGSmartPtrUpcast(ext::shared_ptr< FdmLinearOpCompositeProxy > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmBoundaryCondition > * SWIGSTDCALL CSharp_QuantLib_FdmDirichletBoundary_SWIGSmartPtrUpcast(ext::shared_ptr< FdmDirichletBoundary > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmBoundaryCondition >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmBoundaryCondition > * SWIGSTDCALL CSharp_QuantLib_FdmDiscountDirichletBoundary_SWIGSmartPtrUpcast(ext::shared_ptr< FdmDiscountDirichletBoundary > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmBoundaryCondition >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmBoundaryCondition > * SWIGSTDCALL CSharp_QuantLib_FdmTimeDepDirichletBoundary_SWIGSmartPtrUpcast(ext::shared_ptr< FdmTimeDepDirichletBoundary > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmBoundaryCondition >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_FdmBatesOp_SWIGSmartPtrUpcast(ext::shared_ptr< FdmBatesOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_FdmBlackScholesOp_SWIGSmartPtrUpcast(ext::shared_ptr< FdmBlackScholesOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_Fdm2dBlackScholesOp_SWIGSmartPtrUpcast(ext::shared_ptr< Fdm2dBlackScholesOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_FdmCEVOp_SWIGSmartPtrUpcast(ext::shared_ptr< FdmCEVOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_FdmG2Op_SWIGSmartPtrUpcast(ext::shared_ptr< FdmG2Op > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_FdmHestonHullWhiteOp_SWIGSmartPtrUpcast(ext::shared_ptr< FdmHestonHullWhiteOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_FdmHestonOp_SWIGSmartPtrUpcast(ext::shared_ptr< FdmHestonOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_FdmHullWhiteOp_SWIGSmartPtrUpcast(ext::shared_ptr< FdmHullWhiteOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_FdmLocalVolFwdOp_SWIGSmartPtrUpcast(ext::shared_ptr< FdmLocalVolFwdOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_FdmOrnsteinUhlenbeckOp_SWIGSmartPtrUpcast(ext::shared_ptr< FdmOrnsteinUhlenbeckOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_FdmSabrOp_SWIGSmartPtrUpcast(ext::shared_ptr< FdmSabrOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_FdmZabrOp_SWIGSmartPtrUpcast(ext::shared_ptr< FdmZabrOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_FdmDupire1dOp_SWIGSmartPtrUpcast(ext::shared_ptr< FdmDupire1dOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_FdmBlackScholesFwdOp_SWIGSmartPtrUpcast(ext::shared_ptr< FdmBlackScholesFwdOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_FdmSquareRootFwdOp_SWIGSmartPtrUpcast(ext::shared_ptr< FdmSquareRootFwdOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOpComposite > * SWIGSTDCALL CSharp_QuantLib_FdmHestonFwdOp_SWIGSmartPtrUpcast(ext::shared_ptr< FdmHestonFwdOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOpComposite >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOp > * SWIGSTDCALL CSharp_QuantLib_TripleBandLinearOp_SWIGSmartPtrUpcast(ext::shared_ptr< TripleBandLinearOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOp >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< TripleBandLinearOp > * SWIGSTDCALL CSharp_QuantLib_FirstDerivativeOp_SWIGSmartPtrUpcast(ext::shared_ptr< FirstDerivativeOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< TripleBandLinearOp >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< TripleBandLinearOp > * SWIGSTDCALL CSharp_QuantLib_SecondDerivativeOp_SWIGSmartPtrUpcast(ext::shared_ptr< SecondDerivativeOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< TripleBandLinearOp >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOp > * SWIGSTDCALL CSharp_QuantLib_NinePointLinearOp_SWIGSmartPtrUpcast(ext::shared_ptr< NinePointLinearOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOp >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< NinePointLinearOp > * SWIGSTDCALL CSharp_QuantLib_SecondOrderMixedDerivativeOp_SWIGSmartPtrUpcast(ext::shared_ptr< SecondOrderMixedDerivativeOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< NinePointLinearOp >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmLinearOp > * SWIGSTDCALL CSharp_QuantLib_NthOrderDerivativeOp_SWIGSmartPtrUpcast(ext::shared_ptr< NthOrderDerivativeOp > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmLinearOp >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StepCondition< Array > > * SWIGSTDCALL CSharp_QuantLib_FdmStepConditionProxy_SWIGSmartPtrUpcast(ext::shared_ptr< FdmStepConditionProxy > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StepCondition< Array > >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmInnerValueCalculator > * SWIGSTDCALL CSharp_QuantLib_FdmInnerValueCalculatorProxy_SWIGSmartPtrUpcast(ext::shared_ptr< FdmInnerValueCalculatorProxy > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmInnerValueCalculator >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmInnerValueCalculator > * SWIGSTDCALL CSharp_QuantLib_FdmCellAveragingInnerValue_SWIGSmartPtrUpcast(ext::shared_ptr< FdmCellAveragingInnerValue > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmInnerValueCalculator >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmCellAveragingInnerValue > * SWIGSTDCALL CSharp_QuantLib_FdmLogInnerValue_SWIGSmartPtrUpcast(ext::shared_ptr< FdmLogInnerValue > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmCellAveragingInnerValue >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmInnerValueCalculator > * SWIGSTDCALL CSharp_QuantLib_FdmLogBasketInnerValue_SWIGSmartPtrUpcast(ext::shared_ptr< FdmLogBasketInnerValue > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmInnerValueCalculator >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmInnerValueCalculator > * SWIGSTDCALL CSharp_QuantLib_FdmZeroInnerValue_SWIGSmartPtrUpcast(ext::shared_ptr< FdmZeroInnerValue > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmInnerValueCalculator >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmInnerValueCalculator > * SWIGSTDCALL CSharp_QuantLib_FdmAffineG2ModelSwapInnerValue_SWIGSmartPtrUpcast(ext::shared_ptr< FdmAffineModelSwapInnerValue< G2 > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmInnerValueCalculator >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FdmInnerValueCalculator > * SWIGSTDCALL CSharp_QuantLib_FdmAffineHullWhiteModelSwapInnerValue_SWIGSmartPtrUpcast(ext::shared_ptr< FdmAffineModelSwapInnerValue< HullWhite > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FdmInnerValueCalculator >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StepCondition< Array > > * SWIGSTDCALL CSharp_QuantLib_FdmSnapshotCondition_SWIGSmartPtrUpcast(ext::shared_ptr< FdmSnapshotCondition > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StepCondition< Array > >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StepCondition< Array > > * SWIGSTDCALL CSharp_QuantLib_FdmStepConditionComposite_SWIGSmartPtrUpcast(ext::shared_ptr< FdmStepConditionComposite > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StepCondition< Array > >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StepCondition< Array > > * SWIGSTDCALL CSharp_QuantLib_FdmAmericanStepCondition_SWIGSmartPtrUpcast(ext::shared_ptr< FdmAmericanStepCondition > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StepCondition< Array > >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StepCondition< Array > > * SWIGSTDCALL CSharp_QuantLib_FdmArithmeticAverageCondition_SWIGSmartPtrUpcast(ext::shared_ptr< FdmArithmeticAverageCondition > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StepCondition< Array > >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StepCondition< Array > > * SWIGSTDCALL CSharp_QuantLib_FdmBermudanStepCondition_SWIGSmartPtrUpcast(ext::shared_ptr< FdmBermudanStepCondition > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StepCondition< Array > >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StepCondition< Array > > * SWIGSTDCALL CSharp_QuantLib_FdmSimpleStorageCondition_SWIGSmartPtrUpcast(ext::shared_ptr< FdmSimpleStorageCondition > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StepCondition< Array > >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StepCondition< Array > > * SWIGSTDCALL CSharp_QuantLib_FdmSimpleSwingCondition_SWIGSmartPtrUpcast(ext::shared_ptr< FdmSimpleSwingCondition > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StepCondition< Array > >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StepCondition< Array > > * SWIGSTDCALL CSharp_QuantLib_FdmDividendHandler_SWIGSmartPtrUpcast(ext::shared_ptr< FdmDividendHandler > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StepCondition< Array > >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RiskNeutralDensityCalculator > * SWIGSTDCALL CSharp_QuantLib_BSMRNDCalculator_SWIGSmartPtrUpcast(ext::shared_ptr< BSMRNDCalculator > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RiskNeutralDensityCalculator >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RiskNeutralDensityCalculator > * SWIGSTDCALL CSharp_QuantLib_CEVRNDCalculator_SWIGSmartPtrUpcast(ext::shared_ptr< CEVRNDCalculator > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RiskNeutralDensityCalculator >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RiskNeutralDensityCalculator > * SWIGSTDCALL CSharp_QuantLib_GBSMRNDCalculator_SWIGSmartPtrUpcast(ext::shared_ptr< GBSMRNDCalculator > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RiskNeutralDensityCalculator >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RiskNeutralDensityCalculator > * SWIGSTDCALL CSharp_QuantLib_HestonRNDCalculator_SWIGSmartPtrUpcast(ext::shared_ptr< HestonRNDCalculator > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RiskNeutralDensityCalculator >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RiskNeutralDensityCalculator > * SWIGSTDCALL CSharp_QuantLib_LocalVolRNDCalculator_SWIGSmartPtrUpcast(ext::shared_ptr< LocalVolRNDCalculator > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RiskNeutralDensityCalculator >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< RiskNeutralDensityCalculator > * SWIGSTDCALL CSharp_QuantLib_SquareRootProcessRNDCalculator_SWIGSmartPtrUpcast(ext::shared_ptr< SquareRootProcessRNDCalculator > *jarg1) {
    return jarg1 ? new ext::shared_ptr< RiskNeutralDensityCalculator >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_FittedBondDiscountCurve_SWIGSmartPtrUpcast(ext::shared_ptr< FittedBondDiscountCurve > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FittingMethod > * SWIGSTDCALL CSharp_QuantLib_ExponentialSplinesFitting_SWIGSmartPtrUpcast(ext::shared_ptr< ExponentialSplinesFitting > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FittingMethod >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FittingMethod > * SWIGSTDCALL CSharp_QuantLib_NelsonSiegelFitting_SWIGSmartPtrUpcast(ext::shared_ptr< NelsonSiegelFitting > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FittingMethod >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FittingMethod > * SWIGSTDCALL CSharp_QuantLib_SvenssonFitting_SWIGSmartPtrUpcast(ext::shared_ptr< SvenssonFitting > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FittingMethod >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FittingMethod > * SWIGSTDCALL CSharp_QuantLib_CubicBSplinesFitting_SWIGSmartPtrUpcast(ext::shared_ptr< CubicBSplinesFitting > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FittingMethod >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FittingMethod > * SWIGSTDCALL CSharp_QuantLib_SimplePolynomialFitting_SWIGSmartPtrUpcast(ext::shared_ptr< SimplePolynomialFitting > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FittingMethod >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< FittingMethod > * SWIGSTDCALL CSharp_QuantLib_SpreadFittingMethod_SWIGSmartPtrUpcast(ext::shared_ptr< SpreadFittingMethod > *jarg1) {
    return jarg1 ? new ext::shared_ptr< FittingMethod >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_ForwardCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_ForwardRateAgreement_SWIGSmartPtrUpcast(ext::shared_ptr< ForwardRateAgreement > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Instrument >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< TermStructureConsistentModel > * SWIGSTDCALL CSharp_QuantLib_Gaussian1dModel_SWIGSmartPtrUpcast(ext::shared_ptr< Gaussian1dModel > *jarg1) {
    return jarg1 ? new ext::shared_ptr< TermStructureConsistentModel >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Gaussian1dModel > * SWIGSTDCALL CSharp_QuantLib_Gsr_SWIGSmartPtrUpcast(ext::shared_ptr< Gsr > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Gaussian1dModel >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Gaussian1dModel > * SWIGSTDCALL CSharp_QuantLib_MarkovFunctional_SWIGSmartPtrUpcast(ext::shared_ptr< MarkovFunctional > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Gaussian1dModel >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_Gaussian1dCapFloorEngine_SWIGSmartPtrUpcast(ext::shared_ptr< Gaussian1dCapFloorEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_Gaussian1dSwaptionEngine_SWIGSmartPtrUpcast(ext::shared_ptr< Gaussian1dSwaptionEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_Gaussian1dJamshidianSwaptionEngine_SWIGSmartPtrUpcast(ext::shared_ptr< Gaussian1dJamshidianSwaptionEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_Gaussian1dNonstandardSwaptionEngine_SWIGSmartPtrUpcast(ext::shared_ptr< Gaussian1dNonstandardSwaptionEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_Gaussian1dFloatFloatSwaptionEngine_SWIGSmartPtrUpcast(ext::shared_ptr< Gaussian1dFloatFloatSwaptionEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT GaussianQuadrature * SWIGSTDCALL CSharp_QuantLib_GaussLaguerreIntegration_SWIGUpcast(GaussLaguerreIntegration *jarg1) {
    return (GaussianQuadrature *)jarg1;
}

SWIGEXPORT GaussianQuadrature * SWIGSTDCALL CSharp_QuantLib_GaussHermiteIntegration_SWIGUpcast(GaussHermiteIntegration *jarg1) {
    return (GaussianQuadrature *)jarg1;
}

SWIGEXPORT GaussianQuadrature * SWIGSTDCALL CSharp_QuantLib_GaussJacobiIntegration_SWIGUpcast(GaussJacobiIntegration *jarg1) {
    return (GaussianQuadrature *)jarg1;
}

SWIGEXPORT GaussianQuadrature * SWIGSTDCALL CSharp_QuantLib_GaussHyperbolicIntegration_SWIGUpcast(GaussHyperbolicIntegration *jarg1) {
    return (GaussianQuadrature *)jarg1;
}

SWIGEXPORT GaussianQuadrature * SWIGSTDCALL CSharp_QuantLib_GaussLegendreIntegration_SWIGUpcast(GaussLegendreIntegration *jarg1) {
    return (GaussianQuadrature *)jarg1;
}

SWIGEXPORT GaussianQuadrature * SWIGSTDCALL CSharp_QuantLib_GaussChebyshevIntegration_SWIGUpcast(GaussChebyshevIntegration *jarg1) {
    return (GaussianQuadrature *)jarg1;
}

SWIGEXPORT GaussianQuadrature * SWIGSTDCALL CSharp_QuantLib_GaussChebyshev2ndIntegration_SWIGUpcast(GaussChebyshev2ndIntegration *jarg1) {
    return (GaussianQuadrature *)jarg1;
}

SWIGEXPORT GaussianQuadrature * SWIGSTDCALL CSharp_QuantLib_GaussGegenbauerIntegration_SWIGUpcast(GaussGegenbauerIntegration *jarg1) {
    return (GaussianQuadrature *)jarg1;
}

SWIGEXPORT ext::shared_ptr< LocalVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_LocalConstantVol_SWIGSmartPtrUpcast(ext::shared_ptr< LocalConstantVol > *jarg1) {
    return jarg1 ? new ext::shared_ptr< LocalVolTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< LocalVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_LocalVolSurface_SWIGSmartPtrUpcast(ext::shared_ptr< LocalVolSurface > *jarg1) {
    return jarg1 ? new ext::shared_ptr< LocalVolTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< LocalVolSurface > * SWIGSTDCALL CSharp_QuantLib_NoExceptLocalVolSurface_SWIGSmartPtrUpcast(ext::shared_ptr< NoExceptLocalVolSurface > *jarg1) {
    return jarg1 ? new ext::shared_ptr< LocalVolSurface >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< LocalVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_FixedLocalVolSurface_SWIGSmartPtrUpcast(ext::shared_ptr< FixedLocalVolSurface > *jarg1) {
    return jarg1 ? new ext::shared_ptr< LocalVolTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< LocalVolTermStructure > * SWIGSTDCALL CSharp_QuantLib_GridModelLocalVolSurface_SWIGSmartPtrUpcast(ext::shared_ptr< GridModelLocalVolSurface > *jarg1) {
    return jarg1 ? new ext::shared_ptr< LocalVolTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BrownianGenerator > * SWIGSTDCALL CSharp_QuantLib_MTBrownianGenerator_SWIGSmartPtrUpcast(ext::shared_ptr< MTBrownianGenerator > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BrownianGenerator >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BrownianGeneratorFactory > * SWIGSTDCALL CSharp_QuantLib_MTBrownianGeneratorFactory_SWIGSmartPtrUpcast(ext::shared_ptr< MTBrownianGeneratorFactory > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BrownianGeneratorFactory >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BrownianGenerator > * SWIGSTDCALL CSharp_QuantLib_SobolBrownianGenerator_SWIGSmartPtrUpcast(ext::shared_ptr< SobolBrownianGenerator > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BrownianGenerator >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< BrownianGeneratorFactory > * SWIGSTDCALL CSharp_QuantLib_SobolBrownianGeneratorFactory_SWIGSmartPtrUpcast(ext::shared_ptr< SobolBrownianGeneratorFactory > *jarg1) {
    return jarg1 ? new ext::shared_ptr< BrownianGeneratorFactory >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PiecewiseConstantCorrelation > * SWIGSTDCALL CSharp_QuantLib_ExponentialForwardCorrelation_SWIGSmartPtrUpcast(ext::shared_ptr< ExponentialForwardCorrelation > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PiecewiseConstantCorrelation >(*jarg1) : 0;
}

SWIGEXPORT CurveState * SWIGSTDCALL CSharp_QuantLib_LMMCurveState_SWIGUpcast(LMMCurveState *jarg1) {
    return (CurveState *)jarg1;
}

SWIGEXPORT ext::shared_ptr< MarketModelEvolver > * SWIGSTDCALL CSharp_QuantLib_LogNormalFwdRateIpc_SWIGSmartPtrUpcast(ext::shared_ptr< LogNormalFwdRateIpc > *jarg1) {
    return jarg1 ? new ext::shared_ptr< MarketModelEvolver >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< MarketModel > * SWIGSTDCALL CSharp_QuantLib_AbcdVol_SWIGSmartPtrUpcast(ext::shared_ptr< AbcdVol > *jarg1) {
    return jarg1 ? new ext::shared_ptr< MarketModel >(*jarg1) : 0;
}

SWIGEXPORT AbcdMathFunction * SWIGSTDCALL CSharp_QuantLib_AbcdFunction_SWIGUpcast(AbcdFunction *jarg1) {
    return (AbcdMathFunction *)jarg1;
}

SWIGEXPORT ext::shared_ptr< OneAssetOption > * SWIGSTDCALL CSharp_QuantLib_ContinuousFloatingLookbackOption_SWIGSmartPtrUpcast(ext::shared_ptr< ContinuousFloatingLookbackOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OneAssetOption > * SWIGSTDCALL CSharp_QuantLib_ContinuousFixedLookbackOption_SWIGSmartPtrUpcast(ext::shared_ptr< ContinuousFixedLookbackOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ContinuousFloatingLookbackOption > * SWIGSTDCALL CSharp_QuantLib_ContinuousPartialFloatingLookbackOption_SWIGSmartPtrUpcast(ext::shared_ptr< ContinuousPartialFloatingLookbackOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ContinuousFloatingLookbackOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< ContinuousFixedLookbackOption > * SWIGSTDCALL CSharp_QuantLib_ContinuousPartialFixedLookbackOption_SWIGSmartPtrUpcast(ext::shared_ptr< ContinuousPartialFixedLookbackOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< ContinuousFixedLookbackOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticContinuousFloatingLookbackEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticContinuousFloatingLookbackEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticContinuousFixedLookbackEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticContinuousFixedLookbackEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticContinuousPartialFloatingLookbackEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticContinuousPartialFloatingLookbackEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_AnalyticContinuousPartialFixedLookbackEngine_SWIGSmartPtrUpcast(ext::shared_ptr< AnalyticContinuousPartialFixedLookbackEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< DefaultBoundaryCondition > * SWIGSTDCALL CSharp_QuantLib_NeumannBC_SWIGSmartPtrUpcast(ext::shared_ptr< NeumannBC > *jarg1) {
    return jarg1 ? new ext::shared_ptr< DefaultBoundaryCondition >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< DefaultBoundaryCondition > * SWIGSTDCALL CSharp_QuantLib_DirichletBC_SWIGSmartPtrUpcast(ext::shared_ptr< DirichletBC > *jarg1) {
    return jarg1 ? new ext::shared_ptr< DefaultBoundaryCondition >(*jarg1) : 0;
}

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 ext::shared_ptr< StochasticProcess > * SWIGSTDCALL CSharp_QuantLib_HestonSLVProcess_SWIGSmartPtrUpcast(ext::shared_ptr< HestonSLVProcess > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StochasticProcess >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< MultiAssetOption > * SWIGSTDCALL CSharp_QuantLib_SpreadOption_SWIGSmartPtrUpcast(ext::shared_ptr< SpreadOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< MultiAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_KirkSpreadOptionEngine_SWIGSmartPtrUpcast(ext::shared_ptr< KirkSpreadOptionEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT Statistics * SWIGSTDCALL CSharp_QuantLib_RiskStatistics_SWIGUpcast(RiskStatistics *jarg1) {
    return (Statistics *)jarg1;
}

SWIGEXPORT ext::shared_ptr< VolatilityTermStructure > * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolatilityStructure_SWIGSmartPtrUpcast(ext::shared_ptr< CapFloorTermVolatilityStructure > *jarg1) {
    return jarg1 ? new ext::shared_ptr< VolatilityTermStructure >(*jarg1) : 0;
}

SWIGEXPORT Handle< CapFloorTermVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_RelinkableCapFloorTermVolatilityStructureHandle_SWIGUpcast(RelinkableHandle< CapFloorTermVolatilityStructure > *jarg1) {
    return (Handle< CapFloorTermVolatilityStructure > *)jarg1;
}

SWIGEXPORT ext::shared_ptr< CapFloorTermVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolCurve_SWIGSmartPtrUpcast(ext::shared_ptr< CapFloorTermVolCurve > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CapFloorTermVolatilityStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< CapFloorTermVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_CapFloorTermVolSurface_SWIGSmartPtrUpcast(ext::shared_ptr< CapFloorTermVolSurface > *jarg1) {
    return jarg1 ? new ext::shared_ptr< CapFloorTermVolatilityStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StrippedOptionletBase > * SWIGSTDCALL CSharp_QuantLib_StrippedOptionlet_SWIGSmartPtrUpcast(ext::shared_ptr< StrippedOptionlet > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StrippedOptionletBase >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< StrippedOptionletBase > * SWIGSTDCALL CSharp_QuantLib_OptionletStripper1_SWIGSmartPtrUpcast(ext::shared_ptr< OptionletStripper1 > *jarg1) {
    return jarg1 ? new ext::shared_ptr< StrippedOptionletBase >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OptionletVolatilityStructure > * SWIGSTDCALL CSharp_QuantLib_StrippedOptionletAdapter_SWIGSmartPtrUpcast(ext::shared_ptr< StrippedOptionletAdapter > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OptionletVolatilityStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Option > * SWIGSTDCALL CSharp_QuantLib_Swaption_SWIGSmartPtrUpcast(ext::shared_ptr< Swaption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Option >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_NonstandardSwaption_SWIGSmartPtrUpcast(ext::shared_ptr< NonstandardSwaption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Instrument >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< Instrument > * SWIGSTDCALL CSharp_QuantLib_FloatFloatSwaption_SWIGSmartPtrUpcast(ext::shared_ptr< FloatFloatSwaption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< Instrument >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BlackSwaptionEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BlackSwaptionEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_BachelierSwaptionEngine_SWIGSmartPtrUpcast(ext::shared_ptr< BachelierSwaptionEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< OneAssetOption > * SWIGSTDCALL CSharp_QuantLib_VanillaSwingOption_SWIGSmartPtrUpcast(ext::shared_ptr< VanillaSwingOption > *jarg1) {
    return jarg1 ? new ext::shared_ptr< OneAssetOption >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdSimpleBSSwingEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdSimpleBSSwingEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< PricingEngine > * SWIGSTDCALL CSharp_QuantLib_FdSimpleExtOUJumpSwingEngine_SWIGSmartPtrUpcast(ext::shared_ptr< FdSimpleExtOUJumpSwingEngine > *jarg1) {
    return jarg1 ? new ext::shared_ptr< PricingEngine >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_ZeroCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedZeroCurve< Linear > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_LogLinearZeroCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedZeroCurve< LogLinear > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_CubicZeroCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedZeroCurve< Cubic > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_NaturalCubicZeroCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_LogCubicZeroCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_MonotonicCubicZeroCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

SWIGEXPORT ext::shared_ptr< YieldTermStructure > * SWIGSTDCALL CSharp_QuantLib_KrugerZeroCurve_SWIGSmartPtrUpcast(ext::shared_ptr< InterpolatedZeroCurve< Kruger > > *jarg1) {
    return jarg1 ? new ext::shared_ptr< YieldTermStructure >(*jarg1) : 0;
}

#ifdef __cplusplus
}
#endif

